Attachment #191822 for bug #337930

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2008, 2011 Oracle. 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.

package org.eclipse.jpt.common.ui;

import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;

 * adopters on the understanding that any code that uses this API will almost
 * certainly be broken (repeatedly) as the API evolves.
 *
 * @version 3.0
 * @since 3.0
 */
public interface WidgetFactory {


	 *
	 * @param parent The parent container
	 * @param parent The number of lines the text area should display
	 * @return A new <code>StyledText</code>
	 */
	StyledText createMultiLineStyledText(Composite parent);

	/**
	 * Creates a new editable text area.
	 *
	 * @param parent The parent container
	 * @param parent The number of lines the text area should display
	 * @return A new <code>Text</code>
	 */
	Text createMultiLineText(Composite parent);




package org.eclipse.jpt.common.ui.internal.utility.swt;

import java.util.Arrays;

import org.eclipse.jpt.common.utility.internal.BitTools;
import org.eclipse.jpt.common.utility.internal.StringConverter;
import org.eclipse.jpt.common.utility.internal.model.value.StaticCollectionValueModel;

import org.eclipse.jpt.common.utility.model.value.WritableCollectionValueModel;
import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Control;

		new TextFieldModelBinding(textModel, textField);
	}

	/**
	 * Bind the specified text model to the specified text field.
	 */
	public static <E> void bind(WritablePropertyValueModel<String> textModel, StyledText textField) {
		// the new binding will add itself as a listener to the text model and the text field
		new StyledTextFieldModelBinding(textModel, textField);
	}


	// ********** list box **********





/*******************************************************************************
 * Copyright (c) 2011 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.common.ui.internal.utility.swt;

import org.eclipse.jpt.common.ui.internal.listeners.SWTPropertyChangeListenerWrapper;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent;
import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;

/**
 * This binding can be used to keep a styled text field
 * synchronized with a model text/string.
 * 
 * @see WritablePropertyValueModel
 * @see StyledText
 */
@SuppressWarnings("nls")
class StyledTextFieldModelBinding {

	/**
	 * The text model we keep synchronized with the text field.
	 */
	private final WritablePropertyValueModel<String> textModel;

	/**
	 * A listener that allows us to synchronize the text field's contents with
	 * the text model.
	 */
	private final PropertyChangeListener textModelChangeListener;

	/**
	 * The text field we keep synchronized with the text model.
	 */
	private final StyledText textField;

	/**
	 * A listener that allows us to synchronize our text model
	 * with the text field's contents.
	 */
	private final ModifyListener textFieldModifyListener;

	/**
	 * A listener that allows us to stop listening to stuff when the text field
	 * is disposed.
	 */
	private final DisposeListener textFieldDisposeListener;

	/**
	 * Hmm...
	 */
	private boolean settingTextFieldText = false;


	// ********** constructor **********

	/**
	 * Constructor - the text model and text field are required.
	 */
	StyledTextFieldModelBinding(WritablePropertyValueModel<String> textModel, StyledText textField) {
		super();
		if ((textModel == null) || (textField == null)) {
			throw new NullPointerException();
		}
		this.textModel = textModel;
		this.textField = textField;

		this.textModelChangeListener = this.buildTextModelChangeListener();
		this.textModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.textModelChangeListener);

		this.textFieldModifyListener = this.buildTextFieldModifyListener();
		this.textField.addModifyListener(this.textFieldModifyListener);

		this.textFieldDisposeListener = this.buildTextFieldDisposeListener();
		this.textField.addDisposeListener(this.textFieldDisposeListener);

		this.setTextFieldText(textModel.getValue());
	}


	// ********** initialization **********

	private PropertyChangeListener buildTextModelChangeListener() {
		return new SWTPropertyChangeListenerWrapper(this.buildTextModelChangeListener_());
	}

	private PropertyChangeListener buildTextModelChangeListener_() {
		return new PropertyChangeListener() {
			public void propertyChanged(PropertyChangeEvent event) {
				StyledTextFieldModelBinding.this.textModelChanged(event);
			}
			@Override
			public String toString() {
				return "text listener";
			}
		};
	}

	private ModifyListener buildTextFieldModifyListener() {
		return new ModifyListener() {
			public void modifyText(ModifyEvent event) {
				StyledTextFieldModelBinding.this.textFieldModified();
			}
			@Override
			public String toString() {
				return "text field modify listener";
			}
		};
	}

	private DisposeListener buildTextFieldDisposeListener() {
		return new DisposeListener() {
			public void widgetDisposed(DisposeEvent event) {
				StyledTextFieldModelBinding.this.textFieldDisposed();
			}
			@Override
			public String toString() {
				return "text field dispose listener";
			}
		};
	}


	// ********** text model events **********

	/* CU private */ void textModelChanged(PropertyChangeEvent event) {
		if ( ! this.textField.isDisposed()) {  // ???
			this.setTextFieldText((String) event.getNewValue());
		}
	}

	private void setTextFieldText(String text) {
		// the text model can be null, but the text field cannot
		this.setTextFieldText_((text == null) ? "" : text);
	}

	private void setTextFieldText_(String text) {
		if ( ! text.equals(this.textField.getText())) {  // ???
			this.setTextFieldText__(text);
		}
	}

	private void setTextFieldText__(String text) {
		this.settingTextFieldText = true;
		try {
			this.textField.setText(text);
		} finally {
			this.settingTextFieldText = false;
		}
	}


	// ********** text field events **********

	/* CU private */ void textFieldModified() {
		if ( ! this.settingTextFieldText) {
			this.setTextModelText(this.textField.getText());
		}
	}

	private void setTextModelText(String text) {
		if ( ! text.equals(this.textModel.getValue())) {  // ???
			this.textModel.setValue(text);
		}
	}

	/* CU private */ void textFieldDisposed() {
		// the text field is not yet "disposed" when we receive this event
		// so we can still remove our listeners
		this.textField.removeDisposeListener(this.textFieldDisposeListener);
		this.textField.removeModifyListener(this.textFieldModifyListener);
		this.textModel.removePropertyChangeListener(PropertyValueModel.VALUE, this.textModelChangeListener);
	}


	// ********** standard methods **********

	@Override
	public String toString() {
		return StringTools.buildToStringFor(this, this.textModel);
	}

}




/*******************************************************************************
 * Copyright (c) 2008, 2011 Oracle. 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.

import org.eclipse.jpt.common.ui.WidgetFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;

/**
 * This <code>WidgetFactory</code> simply creates plain SWT widgets.
 *
 * @version 2.3
 * @since 2.3
 */
public class DefaultWidgetFactory implements WidgetFactory {


	public Composite createComposite(Composite parent) {
		return new Composite(parent, SWT.NULL);
	}

	/**
	 * {@inheritDoc}
	 */

	/**
	 * {@inheritDoc}
	 */
	public StyledText createMultiLineStyledText(Composite parent) {
		return new StyledText(parent, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL | SWT.H_SCROLL);
	}

	/**
	 * {@inheritDoc}
	 */
	public Text createMultiLineText(Composite parent) {
		return new Text(parent, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
	}




/*******************************************************************************
 * Copyright (c) 2008, 2011 Oracle. 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.

import org.eclipse.jpt.common.ui.WidgetFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;

 *
 * @see FormToolkit
 *
 * @version 2.3
 * @since 2.3
 */
@SuppressWarnings("nls")
public class FormWidgetFactory implements WidgetFactory {

	protected Composite createBorderContainer(Composite container) {
		return createBorderContainer(container, 2, 1);
	}

	protected Composite createBorderContainer(Composite container, int marginHeight, int marginWidth) {

		GridLayout layout = new GridLayout(1, false);


		return container;
	}

	/**
	 * {@inheritDoc}
	 */

	/**
	 * {@inheritDoc}
	 */
	public StyledText createMultiLineStyledText(Composite parent) {
		return createStyledText(parent, SWT.MULTI | SWT.WRAP | SWT.V_SCROLL | SWT.H_SCROLL);
	}

	/**
	 * {@inheritDoc}
	 */
	public Text createMultiLineText(Composite parent) {
		return createText(parent, SWT.MULTI | SWT.V_SCROLL);
	}

		return createText(parent, SWT.NONE);
	}

	protected StyledText createStyledText(Composite parent, int style) {
		StyledText text = new StyledText(parent, SWT.BORDER | SWT.FLAT | style);
		widgetFactory.adapt(text, true, false);
		return text;
	}

	protected Text createText(Composite parent, int style) {
		return widgetFactory.createText(parent, null, SWT.BORDER | SWT.FLAT | style);
	}




/*******************************************************************************
 * Copyright (c) 2008, 2011 Oracle. 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.

import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;

 * @see FormPane
 * @see DialogPane
 *
 * @version 2.3
 * @since 2.3
 */
@SuppressWarnings("nls")
public abstract class Pane<T extends Model>

	 * @param stringConverter The converter responsible to transform each item
	 * into a string representation
	 * @param helpId The topic help ID to be registered for the given center
	 * composite
	 * @return The newly created <code>Combo</code>
	 *
	 * @category Layout

	}

	/**
	 * Adjusts the layout of the given container so that the text control has the correct amount of
	 * lines by default.
	 */
	private void adjustMultiLineTextLayout(Composite container,
	                                       int lineCount,
	                                       Control text,
	                                       int lineHeight) {

		int textHeight = text.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;

		// Specify the number of lines the text area should display
		GridData gridData = (GridData) text.getLayoutData();
		gridData.heightHint = lineHeight * lineCount;

		// Move the label to the top of its cell
		Control label = container.getChildren()[0];
		int labelHeight = label.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;

		gridData = (GridData) label.getLayoutData();
		gridData.verticalAlignment = SWT.TOP;
		gridData.verticalIndent   += (Math.abs(textHeight - labelHeight) / 2);
	}

	/**
	 * Creates a new container that will have a text field as the center control
	 * labeled with the given label.
	 *

	 * @category Layout
	 */
	protected final Text addLabeledMultiLineText(Composite container,
	                                             String labelText,
	                                             WritablePropertyValueModel<String> textHolder,
	                                             int lineCount,
	                                             String helpId) {

		Text text = this.addMultiLineText(container, textHolder, lineCount);


			helpId
		);

		adjustMultiLineTextLayout(container, lineCount, text, text.getLineHeight());

		return text;
	}
		gridData.heightHint = text.getLineHeight() * lineCount;

	/**
	 * Creates a new container that will have a text field as the center control
	 * labeled with the given label.
	 *
	 * @param container The parent container
	 * @param labelText The text area's label
	 * @param textHolder The holder of the text field's input
	 * @param lineCount The number of lines the text area should display
	 * @param helpId The topic help ID to be registered for the text field
	 * @return The newly created <code>StyledText</code>
	 *
	 * @category Layout
	 */
	protected final StyledText addLabeledMultiLineStyledText(Composite container,
	                                                         String labelText,
	                                                         WritablePropertyValueModel<String> textHolder,
	                                                         int lineCount,
	                                                         String helpId) {

		StyledText text = this.addMultiLineStyledText(container, textHolder, lineCount);

		container = this.addLabeledComposite(
			container,
			labelText,
			text,
			helpId
		);

		adjustMultiLineTextLayout(container, lineCount, text, text.getLineHeight());

		return text;
	}

	}

	/**
	 * Creates a new label expanding on multiple lines.
	 *
	 * @param parent The parent container
	 * @param labelText The label's text
	 *
	 * @category Layout
	 */
	protected final FormText addMultiLineLabel(Composite container, String labelText) {
	                                         String labelText) {

		FormText label = this.widgetFactory.createMultiLineLabel(container, labelText);
		manageWidget(label);
		return label;

	}
	
	/**
	 * Creates a new <code>StyledText</code> widget that has multiple lines.
	 *
	 * @param container The parent container
	 * @return The newly created <code>StyledText</code> widget
	 */
	protected final StyledText addMultiLineStyledText(Composite container) {

		StyledText text = this.widgetFactory.createMultiLineStyledText(container);
		text.setLayoutData(getFieldGridData());
		this.manageWidget(text);

		return text;
	}

	/**
	 * Creates a new <code>Text</code> widget that has multiple lines.
	 *
	 * @param container The parent container

	}

	/**
	 * Creates a new <code>StyledText</code> widget that has multiple lines.
	 *
	 * @param container The parent container
	 * @param lineCount The number of lines the text area should display
	 * @param helpId The topic help ID to be registered for the new text
	 * @return The newly created <code>StyledText</code> widget
	 *
	 * @category Layout
	 */
	protected final StyledText addMultiLineStyledText(Composite container,
	                                                  int lineCount,
	                                                  String helpId) {

		StyledText text = this.addMultiLineStyledText(container);

		GridData gridData   = getFieldGridData();
		gridData.heightHint = text.getLineHeight() * lineCount;
		text.setLayoutData(gridData);

		if (helpId != null) {
			getHelpSystem().setHelp(text, helpId);
		}

		return text;
	}

	/**
	 * Creates a new <code>Text</code> widget that has multiple lines.
	 *
	 * @param container The parent container

	 * @category Layout
	 */
	protected final Text addMultiLineText(Composite container,
	                                      WritablePropertyValueModel<String> textHolder,
	                                      int lineCount) {

		return this.addMultiLineText(container, textHolder, lineCount, null);
	}

	/**
	 * Creates a new <code>StyledText</code> widget that has multiple lines.
	 *
	 * @param container The parent container
	 * @param textHolder The holder of the text field's input
	 * @param lineCount The number of lines the text area should display
	 * @return The newly created <code>StyledText</code> widget
	 *
	 * @category Layout
	 */
	protected final StyledText addMultiLineStyledText(Composite container,
	                                                  WritablePropertyValueModel<String> textHolder,
	                                                  int lineCount) {

		return this.addMultiLineStyledText(container, textHolder, lineCount, null);
	}

	/**
	 * Creates a new <code>Text</code> widget that has multiple lines.
	 *
	 * @param container The parent container

	 * @category Layout
	 */
	protected final Text addMultiLineText(Composite container,
	                                      WritablePropertyValueModel<String> textHolder,
	                                      int lineCount,
	                                      String helpId) {

		Text text = this.addMultiLineText(container, lineCount, helpId);
		SWTTools.bind(textHolder, text);

	}

	/**
	 * Creates a new <code>StyledText</code> widget that has multiple lines.
	 *
	 * @param container The parent container
	 * @param textHolder The holder of the text field's input
	 * @param helpId The topic help ID to be registered for the new text
	 * @return The newly created <code>StyledText</code> widget
	 *
	 * @category Layout
	 */
	protected final StyledText addMultiLineStyledText(Composite container,
	                                                  WritablePropertyValueModel<String> textHolder,
	                                                  int lineCount,
	                                                  String helpId) {

		StyledText text = this.addMultiLineStyledText(container, lineCount, helpId);
		SWTTools.bind(textHolder, text);
		return text;
	}

	/**
	 * Creates a new <code>PageBook</code> and set the proper layout and layout
	 * data.
	 *




################################################################################
# Copyright (c) 2011 Oracle. 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:
#     Oracle - initial API and implementation
################################################################################

# AbsExpression - Grammar
ABS_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
ABS_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression must be provided for an ABS expression.
ABS_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ABS expression.
ABS_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ABS expression.
# AbsExpression - Semantic
ABS_EXPRESSION_INVALID_NUMERIC_EXPRESSION = The encapsulated expression is not a valid numeric expression.

# AbstractFromClause - Grammar
ABSTRACT_FROM_CLAUSE_IDENTIFICATION_VARIABLE_DECLARATION_ENDS_WITH_COMMA = The FROM clause cannot end with a comma.
ABSTRACT_FROM_CLAUSE_IDENTIFICATION_VARIABLE_DECLARATION_IS_MISSING_COMMA = The FROM clause has ''{0}'' and ''{1}'' that are not separated by a comma.
ABSTRACT_FROM_CLAUSE_MISSING_IDENTIFICATION_VARIABLE_DECLARATION = The FROM clause must defined at least one identification variable declaration.
ABSTRACT_FROM_CLAUSE_WRONG_ORDER_OF_IDENTIFICATION_VARIABLE_DECLARATION = The identification variable ''{0}'' is declared after its usage. Identification variables are evaluated from left to right.

# AbstractPathExpression - Grammar
ABSTRACT_PATH_EXPRESSION_CANNOT_END_WITH_COMMA = A path expression cannot end with a comma.
ABSTRACT_PATH_EXPRESSION_MISSING_IDENTIFICATION_VARIABLE = A path expression must start with an identification variable.

# AbstractSchemaName - Grammar
ABSTRACT_SCHEMA_NAME_INVALID = The abstract schema type ''{0}'' is unknown.
ABSTRACT_SCHEMA_NAME_NOT_RESOLVABLE = ''{0}'' cannot be resolved to a type.
# AbstractSchemaName - Semantic
PATH_EXPRESSION_NOT_RELATIONSHIP_MAPPING = The derived path ''{0}'' does not represent an association field.

# AbstractSelectClause - Grammar
ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_ENDS_WITH_COMMA = The select expression cannot end with a comma.
ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_IS_MISSING_COMMA = The SELECT clause has ''{0}'' and ''{1}'' that are not separated by a comma.
ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_MALFORMED = The select expression is malformed.
ABSTRACT_SELECT_CLAUSE_SELECT_MISSING_EXPRESSION = The select expression is missing from the SELECT clause.

# AbstractSelectStatement - Grammar
ABSTRACT_SELECT_STATEMENT_FROM_CLAUSE_MSSING = A select statement must have a FROM clause.

# AdditionExpression - Semantic
ADDITION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the addition is not a valid arithmetic expression.
ADDITION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the addition is not a valid arithmetic expression.

# AllOrAnyExpression - Grammar
ALL_OR_ANY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
ALL_OR_ANY_EXPRESSION_MISSING_EXPRESSION = The subquery must be provided for an {0} expression.
ALL_OR_ANY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the {0} expression.
ALL_OR_ANY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the {0} expression.
ALL_OR_ANY_EXPRESSION_NOT_PART_OF_COMPARISON_EXPRESSION = The {0} expression must be part of a comparison expression.

# ArithmeticFactor - Grammar
ARITHMETIC_FACTOR_MISSING_EXPRESSION = An arithmetic factor must be followed by an expression.
# ArithmeticFactor - Semantic
ARITHMETIC_FACTOR_INVALID_EXPRESSION = The expression must be an arithmetic expression.

# ArithmeticExpression - Grammar
ARITHMETIC_EXPRESSION_INVALID_LEFT_EXPRESSION = The left expression is not an arithmetic expression.
ARITHMETIC_EXPRESSION_INVALID_RIGHT_EXPRESSION = The right expression is not an arithmetic expression.
ARITHMETIC_EXPRESSION_MISSING_LEFT_EXPRESSION = The left expression is missing from the arithmetic expression.
ARITHMETIC_EXPRESSION_MISSING_RIGHT_EXPRESSION = The right expression is missing from the arithmetic expression.

# AvgFunction - Grammar
AVG_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
AVG_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the AVG expression.
AVG_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for an AVG expression.
AVG_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the AVG expression.
# AvgFunction - Semantic
AVG_FUNCTION_INVALID_NUMERIC_EXPRESSION = The encapsulated expression is not a valid numeric expression.

# BetweenExpression - Grammar
BETWEEN_EXPRESSION_MISSING_EXPRESSION = The result expression is missing from the BETWEEN expression.
BETWEEN_EXPRESSION_MISSING_LOWER_BOUND_EXPRESSION = The lower bound expression is missing from the BETWEEN expression.
BETWEEN_EXPRESSION_MISSING_AND = The identifier AND is missing from the BETWEEN expression.
BETWEEN_EXPRESSION_MISSING_UPPER_BOUND_EXPRESSION = The upper bound expression is missing from the BETWEEN expression.
# BetweenExpression - Semantic
BETWEEN_EXPRESSION_WRONG_TYPE = The expression's type and the lower and upper bound expressions' type have to be the same type.

# CaseExpression - Grammar
CASE_EXPRESSION_MISSING_ELSE_EXPRESSION = A CASE expression must have an ELSE expression.
CASE_EXPRESSION_MISSING_ELSE_IDENTIFIER = The identifier ELSE is missing from the CASE expression.
CASE_EXPRESSION_MISSING_END_IDENTIFIER = The identifier END is missing from the CASE expression.
CASE_EXPRESSION_MISSING_WHEN_CLAUSE = A CASE expression must define at least one WHEN clause.
CASE_EXPRESSION_WHEN_CLAUSES_END_WITH_COMMA = The WHEN clauses cannot end with a comma.
CASE_EXPRESSION_WHEN_CLAUSES_HAS_COMMA = Two WHEN clauses cannot be separated by a comma.

# CoalesceExpression - Grammar
COALESCE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
COALESCE_EXPRESSION_MISSING_EXPRESSION = The encapsulated expressions must be provided for a COALESCE expression.
COALESCE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the COALESCE expression.
COALESCE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the COALESCE expression.

# CollectionExpression - Grammar
COLLECTION_EXPRESSION_MISSING_EXPRESSION = An expression at position {0} must be defined.

# CollectionMemberExpression - Grammar
COLLECTION_MEMBER_EXPRESSION_MISSING_ENTITY_EXPRESSION = A collection member expression must define an entity expression.
COLLECTION_MEMBER_EXPRESSION_MISSING_COLLECTION_VALUED_PATH_EXPRESSION = A collection member expression must define a collection valued path expression.
# CollectionMemberExpression - Semantic
COLLECTION_MEMBER_EXPRESSION_EMBEDDABLE = An embeddable type is not supported.

# CollectionMemberDeclaration - Grammar
COLLECTION_MEMBER_DECLARATION_MISSING_COLLECTION_VALUED_PATH_EXPRESSION = The collection-valued path expression is missing from the collection member declaration.
COLLECTION_MEMBER_DECLARATION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the collection member declaration.
COLLECTION_MEMBER_DECLARATION_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be specified for a collection member declaration.
COLLECTION_MEMBER_DECLARATION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the collection member declaration.

# CollectionValuedPathExpression - Semantic
COLLECTION_VALUED_PATH_EXPRESSION_NOT_RESOLVABLE" ,     "The collection-valued path ''{0}'' cannot be resolved to a valid association field.
COLLECTION_VALUED_PATH_EXPRESSION_NOT_COLLECTION_TYPE = The collection-valued path ''{0}'' must resolve to an association field.

# ComparisonExpression - Grammar
COMPARISON_EXPRESSION_MISSING_LEFT_EXPRESSION = A comparison expression must define the left side of the comparison.
COMPARISON_EXPRESSION_MISSING_RIGHT_EXPRESSION = A comparison expression must define the right side of the comparison.
# ComparisonExpression - Semantic
COMPARISON_EXPRESSION_WRONG_COMPARISON_TYPE = The left and right expressions' type must be of the same type.

# ConcatExpression - Grammar
CONCAT_EXPRESSION_INVALID_EXPRESSION = The expression ''{0}'' is not valid expression.
CONCAT_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression is missing from the CONCAT expression.
CONCAT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the CONCAT expression.
CONCAT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the CONCAT expression.
# ConcatExpression - Semantic
CONCAT_EXPRESSION_EXPRESSION_WRONG_TYPE = The expression ''{0}'' is not a String.

# ConstructorExpression - Grammar
CONSTRUCTOR_EXPRESSION_CONSTRUCTOR_ITEM_ENDS_WITH_COMMA = The constructor items cannot end with a comma.
CONSTRUCTOR_EXPRESSION_CONSTRUCTOR_ITEM_IS_MISSING_COMMA = The constructor expression has two constructor items (''{0}'' and ''{1}'') that are not separated by a comma.
CONSTRUCTOR_EXPRESSION_MISSING_CONSTRUCTOR_ITEM = A constructor expression must define at least one constructor item.
CONSTRUCTOR_EXPRESSION_MISSING_CONSTRUCTOR_NAME = The fully qualified class name must be specified.
CONSTRUCTOR_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the constructor expression.
CONSTRUCTOR_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the constructor expression.
# ConstructorExpression - Semantic
CONSTRUCTOR_EXPRESSION_MISMATCHED_PARAMETER_TYPES = No constructors can be found that match the argument types.
CONSTRUCTOR_EXPRESSION_UNKNOWN_TYPE = ''{0}'' cannot be resolved to a type.

# CountFunction - Grammar
COUNT_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
COUNT_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a COUNT expression.
COUNT_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the COUNT expression.
COUNT_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the COUNT expression.
# CountFunction - Semantic
COUNT_FUNCTION_DISTINCT_EMBEDDABLE = The use of DISTINCT is not supported for arguments of embeddable types.

# DateTime - Grammar
DATE_TIME_JDBC_ESCAPE_FORMAT_INVALID_SPECIFICATION = The JDBC escape format does not start with either 'd', 't' or 'ts'.
DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_CLOSE_QUOTE = The JDBC escape format is missing the close quote.
DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_OPEN_QUOTE = The JDBC escape format is missing the open quote.
DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_RIGHT_CURLY_BRACE = The JDBC escape format is missing the right curly brace.

# DeleteClause - Grammar
DELETE_CLAUSE_FROM_MISSING = The identifier FROM is missing from the DELETE FROM clause.
DELETE_CLAUSE_MULTIPLE_RANGE_VARIABLE_DECLARATION = Only one entity abstract schema type can be defined.
DELETE_CLAUSE_RANGE_VARIABLE_DECLARATION_MALFORMED = The entity abstract schema type declaration is malformed.
DELETE_CLAUSE_RANGE_VARIABLE_DECLARATION_MISSING = A DELETE clause must define an entity abstract schema type.

# DivisionExpression - Semantic
DIVISION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the division is not a valid arithmetic expression.
DIVISION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the division is not a valid arithmetic expression.

# EclipseLinkQueryBuilder - Validation
ECLIPSE_LINK_QUERY_BUILDER_GRAMMAR_VALIDATOR_ERROR_MESSAGE = Syntax error parsing the query [{0}]. {1}
ECLIPSE_LINK_QUERY_BUILDER_SEMANTIC_VALIDATOR_ERROR_MESSAGE = Problem compiling the query [{0}]. {1}

# EncapsulatedIdentificationVariableExpression - Semantic
ENCAPSULATED_IDENTIFICATION_VARIABLE_EXPRESSION_NOT_MAP_VALUED = The {0} operator may only be applied to identification variables that correspond to map-valued associations or map-valued element collections.

# EmptyCollectionComparisonExpression - Grammar
EMPTY_COLLECTION_COMPARISON_EXPRESSION_MISSING_EXPRESSION = The collection valued path expression must be defined.

# EntityTypeLiteral - Semantic
ENTITY_TYPE_LITERAL_NOT_RESOLVABLE = ''{0}'' cannot be resolved to a type.

# EntryExpression - Grammar
ENTRY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
ENTRY_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an ENTRY expression.
ENTRY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ENTRY expression.
ENTRY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ENTRY expression.

# ExistsExpression - Grammar
EXISTS_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
EXISTS_EXPRESSION_MISSING_EXPRESSION = A subquery must be provided for an EXISTS expression.
EXISTS_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the EXISTS expression.
EXISTS_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the EXISTS expression.

# FuncExpression - Grammar
FUNC_EXPRESSION_MISSING_FUNCTION_NAME = The SQL function name must be specified.
FUNC_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the FUNC expression.
FUNC_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the FUNC expression.

# GroupByClause - Grammar
GROUP_BY_CLAUSE_GROUP_BY_ITEM_ENDS_WITH_COMMA = The select expression cannot end with a comma.
GROUP_BY_CLAUSE_GROUP_BY_ITEM_IS_MISSING_COMMA = The GROUP BY clause has ''{0}'' and ''{1}'' that are not separated by a comma.
GROUP_BY_CLAUSE_GROUP_BY_ITEM_MISSING = The grouping item is missing from the GROUP BY clause.

# HavingClause - Grammar
HAVING_CLAUSE_INVALID_CONDITIONAL_EXPRESSION = The expression is not a valid conditional expression.
HAVING_CLAUSE_MISSING_CONDITIONAL_EXPRESSION = The conditional expression is missing from the HAVING clause.

# IdentificationVariable - Grammar
IDENTIFICATION_VARIABLE_INVALID_DUPLICATE = The identification variable ''{0}'' cannot be declared more than once.
IDENTIFICATION_VARIABLE_INVALID_JAVA_IDENTIFIER = The identification variable ''{0}'' is not following the rules for a Java identifier.
IDENTIFICATION_VARIABLE_INVALID_RESERVED_WORD = The identification variable ''{0}'' cannot be a reserved word.
# IdentificationVariable - Semantic
IDENTIFICATION_VARIABLE_ENTITY_NAME = An identification variable must not have the same name as any entity in the same persistence unit.
IDENTIFICATION_VARIABLE_INVALID_NOT_DECLARED = The identification variable ''{0}'' is not defined in the FROM clause.

# IdentificationVariableDeclaration - Grammar
IDENTIFICATION_VARIABLE_DECLARATION_MISSING_RANGE_VARIABLE_DECLARATION = The range variable declaration must be specified.

# IndexExpression - Grammar
INDEX_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
INDEX_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an INDEX expression.
INDEX_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the INDEX expression.
INDEX_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the INDEX expression.
# IndexExpression - Semantic
INDEX_EXPRESSION_WRONG_VARIABLE = The identification variable ''{0}'' does not represent an association or element collection.

# InExpression - Grammar
IN_EXPRESSION_IN_ITEM_ENDS_WITH_COMMA = The items cannot end with a comma.
IN_EXPRESSION_IN_ITEM_IS_MISSING_COMMA = The IN expression has ''{0}'' and ''{1}'' that are not separated by a comma.
IN_EXPRESSION_MALFORMED_EXPRESSION = The IN expression does not have a valid state field path expression or TYPE expession.
IN_EXPRESSION_MISSING_IN_ITEMS = A least one item must be defined for the IN expression.
IN_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the IN expression.
IN_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the IN expression.
IN_EXPRESSION_MISSING_EXPRESSION = A state field path expression or TYPE expression must be defined.

# InputParameter - Grammar
INPUT_PARAMETER_JAVA_IDENTIFIER = The named input parameter ''{0}'' is not following the rules for a Java identifier.
INPUT_PARAMETER_MISSING_PARAMETER = The parameter value is missing from the input parameter.
INPUT_PARAMETER_MIXTURE = Named and positional input parameters must not be mixed in a single query.
INPUT_PARAMETER_NOT_INTEGER = The positional input parameter ''{0}'' cannot use non-Integer characters.
INPUT_PARAMETER_SMALLER_THAN_ONE = The number used for the positional input parameter ''{0}'' must be greater than 0.
INPUT_PARAMETER_WRONG_CLAUSE_DECLARATION = Input parameters can only be used in the WHERE clause or HAVING clause of a query.

# Join - Grammar
JOIN_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be defined for a JOIN expression.
JOIN_MISSING_JOIN_ASSOCIATION_PATH = The join association path is missing from the JOIN expression.

# JoinFetch - Grammar
JOIN_FETCH_MISSING_JOIN_ASSOCIATION_PATH = The join association path is missing from the JOIN FETCH expression.
JOIN_FETCH_WRONG_CLAUSE_DECLARATION = JOIN FETCH expressions cannot be used in a FROM clause of a subquery.

# JPQLExpression - Grammar
JPQL_EXPRESSION_INVALID_QUERY = The query does not start with a valid identifier, has to be either SELECT, UPDATE or DELETE FROM.
JPQL_EXPRESSION_UNKNOWN_ENDING = The query contains a malformed ending.

# KeyExpression - Grammar
KEY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
KEY_EXPRESSION_MISSING_EXPRESSION = The identification variable must be provided for an ABS expression.
KEY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ABS expression.
KEY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ABS expression.

# LengthExpression - Grammar
LENGTH_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
LENGTH_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a LENGTH expression.
LENGTH_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LENGTH expression.
LENGTH_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LENGTH expression.
# LikeExpression - Semantic
LENGTH_EXPRESSION_WRONG_TYPE = The encapsulated expression is not of string type.

# LikeExpression - Grammar
LIKE_EXPRESSION_INVALID_ESCAPE_CHARACTER = {0} is not a valid escape character.
LIKE_EXPRESSION_MISSING_ESCAPE_CHARACTER = The escape character is missing from the LIKE expression.
LIKE_EXPRESSION_MISSING_PATTERN_VALUE = The pattern value is missing from the LIKE expression.
LIKE_EXPRESSION_MISSING_STRING_EXPRESSION = The string expression is missing from the LIKE expression.

# LocateExpression - Grammar
LOCATE_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression.
LOCATE_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression.
LOCATE_EXPRESSION_INVALID_THIRD_EXPRESSION = The third argument is not a valid expression.
LOCATE_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_FIRST_COMMA = The first comma is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_SECOND_COMMA = The second comma is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the LOCATE expression.
LOCATE_EXPRESSION_MISSING_THIRD_EXPRESSION = The third argument is missing from the LOCATE expression.
# LocateExpression - Semantic
LOCATE_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first expression is not of string type.
LOCATE_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The second expression is not of string type.
LOCATE_EXPRESSION_THIRD_EXPRESSION_WRONG_TYPE = The third encapsulated expression is not of numeric type.

# LogicalExpression - Grammar
LOGICAL_EXPRESSION_INVALID_LEFT_EXPRESSION = The left expression is missing from the logical expression.
LOGICAL_EXPRESSION_INVALID_RIGHT_EXPRESSION = The right expression is missing from the logical expression.
LOGICAL_EXPRESSION_MISSING_LEFT_EXPRESSION = The left expression is not a valid expression.
LOGICAL_EXPRESSION_MISSING_RIGHT_EXPRESSION = The right expression is not a valid expression.

# LowerExpression - Grammar
LOWER_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
LOWER_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a LOWER expression.
LOWER_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LOWER expression.
LOWER_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LOWER expression.
# UpperExpression - Semantic
LOWER_EXPRESSION_WRONG_TYPE = The expression is not a String.

# MaxFunction - Grammar
MAX_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
MAX_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a MAX expression.
MAX_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MAX expression.
MAX_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MAX expression.

# MinFunction - Grammar
MIN_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
MIN_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a MIN expression.
MIN_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MIN expression.
MIN_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MIN expression.

# ModExpression - Grammar
MOD_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression.
MOD_EXPRESSION_INVALID_SECOND_PARENTHESIS = The second argument is not a valid expression.
MOD_EXPRESSION_MISSING_COMMA = The comma is missing from the MOD expression.
MOD_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the MOD expression.
MOD_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MOD expression.
MOD_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MOD expression.
MOD_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the MOD expression.
# ModExpression - Semantic
MOD_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first expression is not an Integer.
MOD_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The second expression is not an Integer.

# MultiplicationExpression - Semantic
MULTIPLICATION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the multiplication is not a valid arithmetic expression.
MULTIPLICATION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the multiplication is not a valid arithmetic expression.

# NotExpression - Grammar
NOT_EXPRESSION_MISSING_EXPRESSION = The expression is missing after the identifier NOT.
# NotExpression - Semantic
NOT_EXPRESSION_WRONG_TYPE = The expression is not of boolean type.

# NullComparisonExpression - Grammar
NULL_COMPARISON_EXPRESSION_MISSING_EXPRESSION = The expression is missing from the null comparison expression.
# NullComparisonExpression - Semantic
NULL_COMPARISON_EXPRESSION_INVALID_TYPE = ''{0}'' cannot be resolved to an embeddable.

# NullIfExpression - Grammar
NULL_IF_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression.
NULL_IF_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression.
NULL_IF_EXPRESSION_MISSING_COMMA = The comma is missing from the NULLIF expression.
NULL_IF_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the NULLIF expression.
NULL_IF_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the NULLIF expression.
NULL_IF_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the NULLIF expression.
NULL_IF_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the NULLIF expression.

# NumericLiteral - Grammar
NUMERIC_LITERAL_INVALID = ''{0}'' is not a valid numeric value.

# ObjectByItem - Grammar
ORDER_BY_ITEM_INVALID_PATH = ''{0}'' is not a valid state field path expression.
ORDER_BY_ITEM_MISSING_STATE_FIELD_PATH_EXPRESSION = A state field path expression must be specified.

# ObjectExpression - Grammar
OBJECT_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
OBJECT_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an OBJECT expression.
OBJECT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the OBJECT expression.
OBJECT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the OBJECT expression.

# OrderByClause - Grammar
ORDER_BY_CLAUSE_ORDER_BY_ITEM_ENDS_WITH_COMMA = The select expression cannot end with a comma.
ORDER_BY_CLAUSE_ORDER_BY_ITEM_IS_MISSING_COMMA = The ORDER BY clause has ''{0}'' and ''{1}'' that are not separated by a comma.
ORDER_BY_CLAUSE_ORDER_BY_ITEM_MISSING = The ordering item is missing from the ORDER BY clause.

# RangeVariableDeclaration - Grammar
RANGE_VARIABLE_DECLARATION_MISSING_ABSTRACT_SCHEMA_NAME = An abstract schema name must be specified.
RANGE_VARIABLE_DECLARATION_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be provider for a range variable declaration.

# ResultVariable - Grammar
RESULT_VARIABLE_MISSING_SELECT_EXPRESSION = The select item is missing from the result variable declaration.
RESULT_VARIABLE_MISSING_RESULT_VARIABLE = The result variable is missing from the select item declaration.

# SelectStatement - Semantic
SELECT_STATEMENT_SELECT_CLAUSE_HAS_NON_AGGREGATE_FUNCTIONS = The select list can only consist of aggregate functions because there is no GROUP BY clause and the HAVING clause is used.

# SimpleSelectClause - Grammar
SIMPLE_SELECT_CLAUSE_NOT_SINGLE_EXPRESSION = Only one expression can be declared in a SELECT clause of a subquery.

# SizeExpression - Grammar
SIZE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
SIZE_EXPRESSION_MISSING_EXPRESSION = A collection-valued path expression must be provided for a SIZE expression.
SIZE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SIZE expression.
SIZE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SIZE expression.

# SqrtExpression - Grammar
SQRT_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
SQRT_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a SQRT expression.
SQRT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SQRT expression.
SQRT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SQRT expression.
# SqrtExpression - Semantic
SQRT_EXPRESSION_WRONG_TYPE = The expression is not a numeric type.

# StateFieldPathExpression - Semantic
STATE_FIELD_PATH_EXPRESSION_ASSOCIATION_FIELD = The association field ''{0}'' cannot be used as a state field path.
STATE_FIELD_PATH_EXPRESSION_COLLECTION_TYPE = The state field path ''{0}'' cannot be resolved to a collection type.
STATE_FIELD_PATH_EXPRESSION_INVALID_ENUM_CONSTANT = ''{0}'' cannot be resolved to an Enum constant.
STATE_FIELD_PATH_EXPRESSION_NO_MAPPING = No mapping is associated with the state field path ''{0}''.
STATE_FIELD_PATH_EXPRESSION_NOT_RESOLVABLE = The state field path ''{0}'' cannot be resolved to a valid type.

# SubExpression - Grammar
SUB_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression is missing.
SUB_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the sub-expression.

# SubstractionExpression - Semantic
SUBTRACTION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the subtraction is not a valid arithmetic expression.
SUBTRACTION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the subtraction is not a valid arithmetic expression.

# SubstringExpression - Grammar
SUBSTRING_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression.
SUBSTRING_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression.
SUBSTRING_EXPRESSION_INVALID_THIRD_EXPRESSION = The third argument is not a valid expression.
SUBSTRING_EXPRESSION_MISSING_FIRST_COMMA = The first comma is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_SECOND_COMMA = The second comma is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the SUBSTRING expression.
SUBSTRING_EXPRESSION_MISSING_THIRD_EXPRESSION = The third argument is missing from the SUBSTRING expression.
# SubstringExpression - Semantic
SUBSTRING_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first argument is not a String value.
SUBSTRING_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The first argument is not an integer value.
SUBSTRING_EXPRESSION_THIRD_EXPRESSION_WRONG_TYPE = The first argument is not an integer value.

# SumFunction - Grammar
SUM_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
SUM_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a SUM expression.
SUM_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SUM expression.
SUM_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SUM expression.
# SumFunction - Semantic
SUM_FUNCTION_WRONG_TYPE = The argument must be numeric.

# TrimExpression - Grammar
TRIM_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
TRIM_EXPRESSION_INVALID_TRIM_CHARACTER = The trim character should be a single-character string literal or a character-valued input parameter (i.e., char or Character).
TRIM_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a TRIM expression.
TRIM_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the TRIM expression.
TRIM_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the TRIM expression.
TRIM_EXPRESSION_NOT_SINGLE_STRING_LITERAL = The trim character should be a single-character string literal.

# TypeExpression - Grammar
TYPE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
TYPE_EXPRESSION_MISSING_EXPRESSION = An identification variable or a path expression must be provided for a TYPE expression.
TYPE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the TYPE expression.
TYPE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the TYPE expression.
# TypeExpression - Semantic

# UpdateClause - Grammar
UPDATE_CLAUSE_MISSING_RANGE_VARIABLE_DECLARATION = The range variable declaration is missing from the UPDATE clause.
UPDATE_CLAUSE_MISSING_SET = The SET identifier is missing from the UPDATE clause.
UPDATE_CLAUSE_MISSING_UPDATE_ITEMS = At least one update item must be specified for an UPDATE clause.
UPDATE_CLAUSE_UPDATE_ITEM_ENDS_WITH_COMMA = The update item cannot end with a comma.
UPDATE_CLAUSE_UPDATE_ITEM_IS_MISSING_COMMA = The UPDATE clause has ''{0}'' and ''{1}'' that are not separated by a comma.

# UpdateItem - Grammar
UPDATE_ITEM_MISSING_EQUAL_SIGN = The equal sign must be specified.
UPDATE_ITEM_MISSING_NEW_VALUE = The new value must be specified.
UPDATE_ITEM_MISSING_STATE_FIELD_PATH_EXPRESSION = The state field path expression is missing.
# UpdateItem - Semantic
UPDATE_ITEM_NOT_ASSIGNABLE = Type mismatch: cannot convert from {0} to {1}.
UPDATE_ITEM_NOT_RESOLVABLE = The state field cannot be resolved.

# UpperExpression - Grammar
UPPER_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
UPPER_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a UPPER expression.
UPPER_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the UPPER expression.
UPPER_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the UPPER expression.
# UpperExpression - Semantic
UPPER_EXPRESSION_WRONG_TYPE = The expression is not a String.

# ValueExpression - Grammar
VALUE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression.
VALUE_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for a VALUE expression.
VALUE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the VALUE expression.
VALUE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the VALUE expression.

# WhenClause - Grammar
WHEN_CLAUSE_MISSING_THEN_EXPRESSION = A conditional expression must be provider for a WHEN clause.
WHEN_CLAUSE_MISSING_THEN_IDENTIFIER = The identifier THEN is missing from the WHEN clause.
WHEN_CLAUSE_MISSING_WHEN_EXPRESSION = A WHEN expression must be provided for a WHEN clause.

# WhereClause - Grammar
WHERE_CLAUSE_INVALID_CONDITIONAL_EXPRESSION = The expression is not a valid conditional expression.
WHERE_CLAUSE_MISSING_CONDITIONAL_EXPRESSION = The conditional expression is missing from the WHERE clause.

Lines 21-27 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/orm/OrmNamedQuery.java (-2 / +3 lines)
21	* stability. It is available at this early stage to solicit feedback from	21	* stability. It is available at this early stage to solicit feedback from
22	* pioneering adopters on the understanding that any code that uses this API	22	* pioneering adopters on the understanding that any code that uses this API
23	* will almost certainly be broken (repeatedly) as the API evolves.	23	* will almost certainly be broken (repeatedly) as the API evolves.
24	*	24	*
25	* @version 2.1	25	* @version 2.1
26	* @since 2.0	26	* @since 2.0
27	*/	27	*/
Lines 32-35 Link Here
32		32
33	// required to resolve ambiguity	33	// required to resolve ambiguity
34	ListIterable<OrmQueryHint> getHints();	34	ListIterable<OrmQueryHint> getHints();
35	}	35
		36	}

Lines 3-9 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/orm/OrmQuery.java (-2 / +4 lines)
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
Lines 23-29 Link Here
23	* stability. It is available at this early stage to solicit feedback from	23	* stability. It is available at this early stage to solicit feedback from
24	* pioneering adopters on the understanding that any code that uses this API	24	* pioneering adopters on the understanding that any code that uses this API
25	* will almost certainly be broken (repeatedly) as the API evolves.	25	* will almost certainly be broken (repeatedly) as the API evolves.
26	*	26	*
27	* @version 2.1	27	* @version 2.1
28	* @since 2.0	28	* @since 2.0
29	*/	29	*/
Lines 46-49 Link Here
46	// ******** validation ********	46	// ******** validation ********
47		47
48	TextRange getNameTextRange();	48	TextRange getNameTextRange();
		49
		50	TextRange getQueryTextRange();
49	}	51	}




package org.eclipse.jpt.jpa.core.internal.context.orm;

import java.util.Vector;

import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneIterable;

	// ********** synchronize/update **********

	@Override
	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.setName_(this.xmlQuery.getName());
		this.setQuery_(this.xmlQuery.getQuery());

		return this.xmlQuery.getNameTextRange();
	}

	public TextRange getQueryTextRange() {
		return this.xmlQuery.getQueryTextRange();
	}

	@Override
	public void toString(StringBuilder sb) {
		sb.append(this.name);

Lines 1-18 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaNamedQuery.java (-3 / +40 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;	10	package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
11		11
		12	import java.util.List;
		13	import org.eclipse.jdt.core.dom.CompilationUnit;
		14	import org.eclipse.jpt.common.core.utility.TextRange;
12	import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;	15	import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
13	import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery;	16	import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery;
14	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;	17	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;
		18	import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
		19	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
		20	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationPreferences;
15	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;	21	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;
		22	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
		23	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		24	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
16		25
17	/**	26	/**
18	* Java named query	27	* Java named query
Lines 24-27 Link Here
24	public GenericJavaNamedQuery(JavaJpaContextNode parent, NamedQueryAnnotation queryAnnotation) {	33	public GenericJavaNamedQuery(JavaJpaContextNode parent, NamedQueryAnnotation queryAnnotation) {
25	super(parent, queryAnnotation);	34	super(parent, queryAnnotation);
26	}	35	}
27	}	36
		37
		38	// ******** validation ********
		39
		40	private boolean shouldValidate() {
		41	return JpaValidationPreferences.getProblemSeverityPreference(this, JpaValidationMessages.JPQL_QUERY_VALIDATION) == -1;
		42	}
		43
		44	/**
		45	* {@inheritDoc}
		46	*/
		47	@Override
		48	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
		49	super.validate(messages, reporter, astRoot);
		50
		51	// Make this quick check so we don't validate the query, which is time consuming
		52	if (shouldValidate()) {
		53	JpaJpqlQueryHelper helper = new JpaJpqlQueryHelper(this);
		54	String parsedJpqlQuery = helper.getParsedJPQLQuery();
		55	String actualQuery = getQuery();
		56
		57	for (JPQLQueryProblem problem : helper.validate()) {
		58	TextRange textRange = this.getQueryAnnotation().getQueryTextRange(astRoot);
		59	IMessage message = helper.buildProblem(this, textRange, problem, parsedJpqlQuery, actualQuery, 1);
		60	messages.add(message);
		61	}
		62	}
		63	}
		64	}

Lines 308-317 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java (-2 / +5 lines)
308	@Override	308	@Override
309	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {	309	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
310	super.validate(messages, reporter, astRoot);	310	super.validate(messages, reporter, astRoot);
311	this.validateQueries(messages, astRoot);	311	this.validateQueries(messages, reporter, astRoot);
312	}	312	}
313		313
314	protected void validateQueries(List<IMessage> messages, CompilationUnit astRoot) {	314	protected void validateQueries(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
315	for (Iterator<JavaQuery> localQueries = this.queries(); localQueries.hasNext(); ) {	315	for (Iterator<JavaQuery> localQueries = this.queries(); localQueries.hasNext(); ) {
316	JavaQuery localQuery = localQueries.next();	316	JavaQuery localQuery = localQueries.next();
317	String name = localQuery.getName();	317	String name = localQuery.getName();
Lines 354-359 Link Here
354	)	354	)
355	);	355	);
356	}	356	}
		357	else {
		358	localQuery.validate(messages, reporter, astRoot);
		359	}
357	}	360	}
358	}	361	}
359		362

Lines 1-18 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmNamedQuery.java (-3 / +38 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;	10	package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
11		11
		12	import java.util.List;
		13	import org.eclipse.jpt.common.core.utility.TextRange;
12	import org.eclipse.jpt.jpa.core.context.XmlContextNode;	14	import org.eclipse.jpt.jpa.core.context.XmlContextNode;
13	import org.eclipse.jpt.jpa.core.context.orm.OrmNamedQuery;	15	import org.eclipse.jpt.jpa.core.context.orm.OrmNamedQuery;
14	import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery;	16	import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery;
		17	import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
		18	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
		19	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationPreferences;
15	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery;	20	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery;
		21	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
		22	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		23	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
16		24
17	/**	25	/**
18	* <code>orm.xml</code> named query	26	* <code>orm.xml</code> named query
Lines 24-27 Link Here
24	public GenericOrmNamedQuery(XmlContextNode parent, XmlNamedQuery resourceNamedQuery) {	32	public GenericOrmNamedQuery(XmlContextNode parent, XmlNamedQuery resourceNamedQuery) {
25	super(parent, resourceNamedQuery);	33	super(parent, resourceNamedQuery);
26	}	34	}
27	}	35
		36	// ******** validation ********
		37
		38	private boolean shouldValidate() {
		39	return JpaValidationPreferences.getProblemSeverityPreference(this, JpaValidationMessages.JPQL_QUERY_VALIDATION) == -1;
		40	}
		41
		42	/**
		43	* {@inheritDoc}
		44	*/
		45	@Override
		46	public void validate(List<IMessage> messages, IReporter reporter) {
		47	super.validate(messages, reporter);
		48
		49	// Make this quick check so we don't validate the query, which is time consuming
		50	if (shouldValidate()) {
		51	JpaJpqlQueryHelper helper = new JpaJpqlQueryHelper(this);
		52	String parsedJpqlQuery = helper.getParsedJPQLQuery();
		53	String actualQuery = getQuery();
		54
		55	for (JPQLQueryProblem problem : helper.validate()) {
		56	TextRange textRange = this.getQueryTextRange();
		57	IMessage message = helper.buildProblem(this, textRange, problem, parsedJpqlQuery, actualQuery, 0);
		58	messages.add(message);
		59	}
		60	}
		61	}
		62	}




import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable;

	@Override
	public void validate(List<IMessage> messages, IReporter reporter) {
		super.validate(messages, reporter);
		this.validateQueries(messages, reporter);
	}

	protected void validateQueries(List<IMessage> messages, IReporter reporter) {
		for (OrmQuery localQuery : this.getQueries()) {
			String name = localQuery.getName();
			if (StringTools.stringIsEmpty(name)){

						)
				);
			}
			else {
				localQuery.validate(messages, reporter);
			}
		}
	}


Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/GenericJavaNamedQuery2_0.java (-2 / +38 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009, 2010 Oracle. All rights reserved.	2	* Copyright (c) 2009, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
Lines 9-19 Link Here
9	*******************************************************************************/	9	*******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.jpa2.context.java;	10	package org.eclipse.jpt.jpa.core.internal.jpa2.context.java;
11		11
		12	import java.util.List;
		13	import org.eclipse.jdt.core.dom.CompilationUnit;
		14	import org.eclipse.jpt.common.core.utility.TextRange;
12	import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;	15	import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
13	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;	16	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;
		17	import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
		18	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
		19	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationPreferences;
14	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;	20	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;
15	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaNamedQuery2_0;	21	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaNamedQuery2_0;
16	import org.eclipse.jpt.jpa.core.jpa2.resource.java.NamedQuery2_0Annotation;	22	import org.eclipse.jpt.jpa.core.jpa2.resource.java.NamedQuery2_0Annotation;
		23	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
		24	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		25	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
17		26
18	/**	27	/**
19	* JPA 2.0	28	* JPA 2.0
Lines 87-90 Link Here
87	return LockModeType2_0.NONE;	96	return LockModeType2_0.NONE;
88	}	97	}
89		98
90	}	99
		100	// ******** validation ********
		101
		102	private boolean shouldValidate() {
		103	return JpaValidationPreferences.getProblemSeverityPreference(this, JpaValidationMessages.JPQL_QUERY_VALIDATION) == -1;
		104	}
		105
		106	/**
		107	* {@inheritDoc}
		108	*/
		109	@Override
		110	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
		111	super.validate(messages, reporter, astRoot);
		112
		113	// Make this quick check so we don't validate the query, which is time consuming
		114	if (shouldValidate()) {
		115	JpaJpqlQueryHelper helper = new JpaJpqlQueryHelper(this);
		116	String parsedJpqlQuery = helper.getParsedJPQLQuery();
		117	String actualQuery = getQuery();
		118
		119	for (JPQLQueryProblem problem : helper.validate()) {
		120	TextRange textRange = this.getQueryAnnotation().getQueryTextRange(astRoot);
		121	IMessage message = helper.buildProblem(this, textRange, problem, parsedJpqlQuery, actualQuery, 1);
		122	messages.add(message);
		123	}
		124	}
		125	}
		126	}

Lines 1-19 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/GenericOrmNamedQuery2_0.java (-3 / +37 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.jpa2.context.orm;	10	package org.eclipse.jpt.jpa.core.internal.jpa2.context.orm;
11		11
		12	import java.util.List;
		13	import org.eclipse.jpt.common.core.utility.TextRange;
12	import org.eclipse.jpt.jpa.core.context.XmlContextNode;	14	import org.eclipse.jpt.jpa.core.context.XmlContextNode;
13	import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery;	15	import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery;
		16	import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
		17	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
		18	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationPreferences;
14	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;	19	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;
15	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmNamedQuery2_0;	20	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmNamedQuery2_0;
16	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery;	21	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery;
		22	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
		23	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		24	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
17		25
18	/**	26	/**
19	* JPA 2.0	27	* JPA 2.0
Lines 87-90 Link Here
87	return LockModeType2_0.NONE;	95	return LockModeType2_0.NONE;
88	}	96	}
89		97
90	}	98	// ******** validation ********
		99
		100	private boolean shouldValidate() {
		101	return JpaValidationPreferences.getProblemSeverityPreference(this, JpaValidationMessages.JPQL_QUERY_VALIDATION) == -1;
		102	}
		103
		104	/**
		105	* {@inheritDoc}
		106	*/
		107	@Override
		108	public void validate(List<IMessage> messages, IReporter reporter) {
		109	super.validate(messages, reporter);
		110
		111	// Make this quick check so we don't validate the query, which is time consuming
		112	if (shouldValidate()) {
		113	JpaJpqlQueryHelper helper = new JpaJpqlQueryHelper(this);
		114	String parsedJpqlQuery = helper.getParsedJPQLQuery();
		115	String actualQuery = getQuery();
		116
		117	for (JPQLQueryProblem problem : helper.validate()) {
		118	TextRange textRange = this.getQueryTextRange();
		119	IMessage message = helper.buildProblem(this, textRange, problem, parsedJpqlQuery, actualQuery, 0);
		120	messages.add(message);
		121	}
		122	}
		123	}
		124	}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.persistence.jpa.jpql.spi.IConstructor;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;

/**
 * The concrete implementation of {@link IConstructor} that is wrapping the design-time
 * representation of a Java constructor.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaConstructor implements IConstructor {

	/**
	 * The design-time representation of a Java constructor.
	 */
	private final MethodDeclaration method;

	/**
	 * The cached {@link ITypeDeclaration ITypeDeclarations} representing each of the constructor's
	 * parameter types.
	 */
	private ITypeDeclaration[] typeDeclarations;

	/**
	 * The repository of Java types.
	 */
	private final JpaTypeRepository typeRepository;

	/**
	 * Creates a new <code>JpaConstructor</code>.
	 *
	 * @param typeRepository The repository of Java types
	 * @param method The design-time representation of a Java constructor
	 */
	JpaConstructor(JpaTypeRepository typeRepository, MethodDeclaration method) {
		super();
		this.method         = method;
		this.typeRepository = typeRepository;
	}

	private ITypeDeclaration buildTypeDeclaration(ITypeBinding parameterType) {

		boolean array = parameterType.isArray();
		String typeName = array ? parameterType.getComponentType().getBinaryName() : parameterType.getBinaryName();

		// Retrieve the fully qualified name of the type
		ITypeBinding[] typeArguments = parameterType.getTypeArguments();
		ITypeDeclaration[] genericTypes = new ITypeDeclaration[typeArguments.length];
		int index = 0;

		for (ITypeBinding typeArgument : typeArguments) {
			String genericTypeName = typeArgument.getErasure().getBinaryName();
			IType genericType = typeRepository.getType(genericTypeName);
			genericTypes[index++] = genericType.getTypeDeclaration();
		}

		return new JpaTypeDeclaration(typeRepository.getType(typeName), genericTypes, array);
	}

	private ITypeDeclaration[] buildTypeDeclarations() {

		IMethodBinding binding = method.resolveBinding();
		ITypeBinding[] parameterTypes = binding.getParameterTypes();
		ITypeDeclaration[] declarations = new ITypeDeclaration[parameterTypes.length];

		for (int index = declarations.length; --index >= 0; ) {
			declarations[index] = buildTypeDeclaration(parameterTypes[index]);
		}

		return declarations;
	}

	/**
	 * {@inheritDoc}
	 */
	public ITypeDeclaration[] getParameterTypes() {
		if (typeDeclarations == null) {
			typeDeclarations = buildTypeDeclarations();
		}
		return typeDeclarations;
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.jpa.core.context.Embeddable;
import org.eclipse.persistence.jpa.jpql.spi.IEmbeddable;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeVisitor;

/**
 * The concrete implementation of {@link IEmbeddable} that is wrapping the design-time
 * representation of a JPA embeddable.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaEmbeddable extends JpaManagedType
                          implements IEmbeddable {

	/**
	 * Creates a new <code>JpaEmbeddable</code>.
	 *
	 * @param provider The provider of JPA managed types
	 * @param embeddable The design-time model object wrapped by this class
	 */
	JpaEmbeddable(JpaManagedTypeProvider provider, Embeddable embeddable) {
		super(provider, embeddable);
	}

	/**
	 * {@inheritDoc}
	 */
	public void accept(IManagedTypeVisitor visitor) {
		visitor.visit(this);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	Embeddable getManagedType() {
		return (Embeddable) super.getManagedType();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.HashMap;
import java.util.ListIterator;
import java.util.Map;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeVisitor;
import org.eclipse.persistence.jpa.jpql.spi.IQuery;

/**
 * The concrete implementation of {@link IEntity} that is wrapping the design-time representation
 * of a JPA entity.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
abstract class JpaEntity extends JpaManagedType
                         implements IEntity {

	/**
	 * The cached used to quickly retrieve any queries that have been cached.
	 */
	private Map<String, IQuery> queries;

	/**
	 * Creates a new <code>JpaEntity</code>.
	 *
	 * @param provider The provider of JPA managed types
	 * @param entity The design-time model object wrapped by this class
	 */
	JpaEntity(JpaManagedTypeProvider provider, Entity entity) {
		super(provider, entity);
	}

	/**
	 * {@inheritDoc}
	 */
	public void accept(IManagedTypeVisitor visitor) {
		visitor.visit(this);
	}

	final IQuery buildQuery(JpaManagedTypeProvider provider, NamedQuery namedQuery) {
		return new JpaQuery(provider, namedQuery);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	Entity getManagedType() {
		return (Entity) super.getManagedType();
	}

	/**
	 * {@inheritDoc}
	 */
	public final String getName() {
		return getManagedType().getName();
	}

	/**
	 * {@inheritDoc}
	 */
	public IQuery getNamedQuery(String queryName) {
		initializeQueries();
		return queries.get(queryName);
	}

	private void initializeQueries() {
		if (queries == null) {
			queries = new HashMap<String, IQuery>();
			initializeQueries(queries);
		}
	}

	void initializeQueries(Map<String, IQuery> queries) {
		JpaManagedTypeProvider provider = getProvider();
		for (ListIterator<NamedQuery> iter = namedQueries(); iter.hasNext(); ) {
			NamedQuery namedQuery = iter.next();
			queries.put(namedQuery.getName(), buildQuery(provider, namedQuery));
		}
	}

	private ListIterator<NamedQuery> namedQueries() {
		return getManagedType().getQueryContainer().namedQueries();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.common.core.internal.utility.SimpleTextRange;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationPreferences;
import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.persistence.jpa.jpql.JPQLQueryHelper;
import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
import org.eclipse.persistence.jpa.jpql.spi.IQuery;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;

/**
 * This helper can perform the following operations over a JPQL query:
 * <ul>
 * <li>Calculates the result type of a query: {@link #getResultType()};</li>
 * <li>Calculates the type of an input parameter: {@link #getParameterType(String)}.</li>
 * <li>Calculates the possible choices to complete the query from a given
 *     position (used for content assist): {@link #buildContentAssistItems(int)}.</li>
 * <li>Validates the query by introspecting its grammar and semantic:
 *     <ul>
 *     <li>{@link #validate()},</li>
 *     <li>{@link #validateGrammar()},</li>
 *     <li>{@link #validateSemantic()}.</li>
 *     </ul></li>
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
public final class JpaJpqlQueryHelper extends JPQLQueryHelper<NamedQuery> {

	/**
	 * The actual JPQL query, which can differ from the one owned by the model object, which happens
	 * when the model is out of sync because it has not been updated yet.
	 */
	private final String actualQuery;

	/**
	 * The external form of the JPQL query that was already created before this helper, which happens
	 * during the execution of the unit-tests.
	 */
	private IQuery localQuery;

	/**
	 * Creates a new <code>JpaJpqlQueryHelper</code>. This constructor is used only by the unit-tests.
	 *
	 * @param query The external form that is already wrapping the {@link MWNamedQuery}
	 * @exception NullPointerException If the query is <code>null</code>
	 */
	public JpaJpqlQueryHelper(IQuery query) {
		this(((JpaQuery) query).getQuery());
		this.localQuery = query;
	}

	/**
	 * Creates a new <code>JpaJpqlQueryHelper</code>.
	 *
	 * @param query The model object where the JPQL query is stored
	 * @exception NullPointerException If the given {@link NamedQuery} is <code>null</code>
	 */
	public JpaJpqlQueryHelper(NamedQuery query) {
		this(query, query.getQuery());
	}

	/**
	 * Creates a new <code>JpaQueryHelper</code>.
	 *
	 * @param query The model object where the JPQL query is stored
	 * @param actualQuery The actual JPQL query, which can differ from the one owned by the model
	 * object, which happens when the model is out of sync because it has not been updated yet
	 * @exception NullPointerException If the given {@link NamedQuery} is <code>null</code>
	 */
	public JpaJpqlQueryHelper(NamedQuery query, String actualQuery) {
		super(query);
		this.actualQuery = actualQuery;
	}

	/**
	 * Calculates the start and end positions by adjusting to the given <em>jpqlQuery</em>, which may
	 * differ from the string representation of the parsed tree since the parsed tree does not keep
	 * track of multiple whitespace but only one. It also increase the length when the start and end
	 * positions are the same.
	 *
	 * @param problem The {@link JPQLQueryProblem problem} that was found in the JPQL query, which is
	 * either a grammatical or semantic problem
	 * @param parsedJpqlQuery The string representation of the parsed tree representation of the JPQL
	 * query, which may differ from the actual JPQL query since it does not keep more than one
	 * whitespace
	 * @param actualQuery The actual JPQL query that was parsed and validated
	 * @return The start and end positions, which may have been adjusted
	 */
	public int[] buildPositions(JPQLQueryProblem problem, String parsedJpqlQuery, String actualQuery) {

		int startPosition = problem.getStartPosition();
		int endPosition   = problem.getEndPosition();

		// If the start and end positions are the same, then expand the text range
		if (startPosition == endPosition) {
			startPosition = Math.max(startPosition - 1, 0);
		}

		// Reposition the cursor so it's correctly positioned in the actual query, which is the
		// since it may contains more than one whitespace for a single whitespace
		int newStartPosition = ExpressionTools.repositionCursor(parsedJpqlQuery, startPosition, actualQuery);

		if (newStartPosition != startPosition) {
			endPosition  += (newStartPosition - startPosition);
			startPosition = newStartPosition;
		}

		return new int[] { startPosition, endPosition };
	}

	/**
	 * Creates a new {@link IMessage} for the given {@link JPQLQueryProblem}.
	 *
	 * @param targetObject The object for which a new {@link IMessage} is creating describing the
	 * problem
	 * @param problem The {@link JPQLQueryProblem problem} that was found in the JPQL query, which is
	 * either a grammatical or semantic problem
	 * @param textRange The range of the JPQL query in the Java source file
	 * @param parsedJpqlQuery The string representation of the parsed tree representation of the JPQL
	 * query, which may differ from the actual JPQL query since it does not keep more than one
	 * whitespace
	 * @param actualQuery The actual JPQL query that was parsed and validated
	 * @param offset This offset is used to move the start position
	 * @return A new {@link IMessage} that has the required information to display the problem
	 * underline and the error message in the Problems view
	 */
	public IMessage buildProblem(Object targetObject,
	                             TextRange textRange,
	                             JPQLQueryProblem problem,
	                             String parsedJpqlQuery,
	                             String actualQuery,
	                             int offset) {

		int[] positions = buildPositions(problem, parsedJpqlQuery, actualQuery);

		// Create the text range of the problem
		textRange = new SimpleTextRange(
			textRange.getOffset() + positions[0] + offset,
			positions[1] - positions[0],
			textRange.getLineNumber()
		);

		// Now create the message
		IMessage message = DefaultJpaValidationMessages.buildMessage(
			severity(targetObject),
			problem.getMessageKey(),
			problem.getMessageArguments(),
			targetObject,
			textRange
		);
		message.setBundleName("jpa_jpql_validation");
		return message;
	}

	private JpaManagedTypeProvider buildProvider(NamedQuery query) {
		try {
			return new JpaPersistenceUnit(query.getJpaProject(), query.getPersistenceUnit());
		}
		catch (Exception e) {
			return new JpaMappingFile(query.getJpaProject(), query.getMappingFileRoot().getParent());
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected IQuery buildQuery(NamedQuery query) {
		if (localQuery == null) {
			localQuery = new JpaQuery(buildProvider(query), query, actualQuery);
		}
		return localQuery;
	}

	/**
	 * Retrieve the severity that is associated to JPQL query validation, which cannot be retrieved
	 * using the JPQL problem message key.

	 * @param targetObject The object for which a new {@link IMessage} is creating describing the
	 * problem
	 * @return The global severity for validating JPQL queries
	 */
	private int severity(Object targetObject) {
		return JpaValidationPreferences.getProblemSeverityPreference(
			targetObject,
			JpaValidationMessages.JPQL_QUERY_VALIDATION
		);
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.jpt.jpa.core.context.AttributeMapping;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IMapping;

/**
 * The abstract definition of {@link IManagedType} defined for wrapping the design-time mapped class
 * object.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
abstract class JpaManagedType implements IManagedType {

	/**
	 * The design-time model object wrapped by this class.
	 */
	private final TypeMapping managedType;

	/**
	 * The cached collection of {@link IMapping mappings} that prevent rebuilding them every time one
	 * is requested.
	 */
	private Map<String, IMapping> mappings;

	/**
	 * The provider of JPA managed types.
	 */
	private final JpaManagedTypeProvider provider;

	/**
	 * The cached wrapper over {@link TODO}.
	 */
	private JpaType type;

	/**
	 * Creates a new <code>JDeveloperManagedType</code>.
	 *
	 * @param managedType The provider of JPA managed types
	 * @param mappedClass The design-time model object wrapped by this class
	 */
	JpaManagedType(JpaManagedTypeProvider provider, TypeMapping managedType) {
		super();
		this.provider    = provider;
		this.managedType = managedType;
	}

	private IMapping buildMapping(AttributeMapping mapping) {
		return new JpaMapping(this, mapping);
	}

	private Map<String, IMapping> buildMappings() {
		Map<String, IMapping> mappings = new HashMap<String, IMapping>();
		for (Iterator<AttributeMapping> iter = managedType.allAttributeMappings(); iter.hasNext(); ) {
			AttributeMapping mapping = iter.next();
			mappings.put(mapping.getName(), buildMapping(mapping));
		}
		return mappings;
	}

	/**
	 * {@inheritDoc}
	 */
	public int compareTo(IManagedType managedType) {
		return getType().getName().compareTo(managedType.getType().getName());
	}

	/**
	 * Returns the encapsulated model object.
	 *
	 * @return The managed type wrapped by this external form
	 */
	TypeMapping getManagedType() {
		return managedType;
	}

	/**
	 * {@inheritDoc}
	 */
	public final IMapping getMappingNamed(String name) {
		initializeMappings();
		return mappings.get(name);
	}

	/**
	 * {@inheritDoc}
	 */
	public final JpaManagedTypeProvider getProvider() {
		return provider;
	}

	/**
	 * {@inheritDoc}
	 */
	public final JpaType getType() {
		if (type == null) {
			type = provider.getTypeRepository().getType(managedType.getPersistentType().getName());
		}
		return type;
	}

	private void initializeMappings() {
		if (mappings == null) {
			mappings = buildMappings();
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public final Iterable<IMapping> mappings() {
		initializeMappings();
		return Collections.unmodifiableCollection(mappings.values());
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.jpt.jpa.core.JpaFacet;
import org.eclipse.jpt.jpa.core.JpaPlatform;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.context.Embeddable;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.MappedSuperclass;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.jpt.jpa.core.context.persistence.PersistentTypeContainer;
import org.eclipse.persistence.jpa.jpql.spi.IEmbeddable;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeProvider;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeVisitor;
import org.eclipse.persistence.jpa.jpql.spi.IMappedSuperclass;
import org.eclipse.persistence.jpa.jpql.spi.IPlatform;
import org.eclipse.persistence.jpa.jpql.spi.IType;

/**
 * The abstract implementation of {@link IManagedTypeProvider} that is wrapping the design-time
 * representation of a provider of managed types.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
abstract class JpaManagedTypeProvider implements IManagedTypeProvider {

	/**
	 * The filtered collection of managed types that are the abstract schema types.
	 */
	private Collection<IEntity> abstractSchemaTypes;

	/**
	 * The project that gives access to the application's metadata.
	 */
	private final JpaProject jpaProject;

	/**
	 * The cached {@link IManagedType managed types}.
	 */
	private Map<String, IManagedType> managedTypes;

	/**
	 * The design-time provider of managed types.
	 */
	private final PersistentTypeContainer persistentTypeContainer;

	/**
	 * The external form of a type repository.
	 */
	private JpaTypeRepository typeRepository;

	/**
	 * The version of the Java Persistence this entity for which it was defined.
	 */
	private IJPAVersion version;

	/**
	 * Creates a new <code>JpaManagedTypeProvider</code>.
	 * 
	 * @param jpaProject The project that gives access to the application's metadata
	 * @param persistentTypeContainer The design-time provider of managed types
	 */
	JpaManagedTypeProvider(JpaProject jpaProject, PersistentTypeContainer persistentTypeContainer) {

		super();
		this.jpaProject = jpaProject;
		this.persistentTypeContainer = persistentTypeContainer;
	}

	/**
	 * {@inheritDoc}
	 */
	public Iterable<IEntity> abstractSchemaTypes() {
		if (abstractSchemaTypes == null) {
			initializeManagedTypes();
			EntityCollector visitor = new EntityCollector();
			for (IManagedType managedType : managedTypes.values()) {
				managedType.accept(visitor);
			}
			abstractSchemaTypes = visitor.entities;
		}
		return Collections.unmodifiableCollection(abstractSchemaTypes);
	}

	abstract JpaEntity buildEntity(TypeMapping mappedClass);

	private IManagedType buildManagedType(PersistentType persistentType) {

		TypeMapping mappedClass = persistentType.getMapping();

		if (mappedClass instanceof Entity) {
			return buildEntity(mappedClass);
		}

		if (mappedClass instanceof MappedSuperclass) {
			return new JpaMappedSuperclass(this, (MappedSuperclass) mappedClass);
		}

		if (mappedClass instanceof Embeddable) {
			return new JpaEmbeddable(this, (Embeddable) mappedClass);
		}

		return new JpaNullManagedType(this, mappedClass);
	}

	private Map<String, IManagedType> buildManagedTypes() {
		Map<String, IManagedType> managedTypes = new HashMap<String, IManagedType>();
		for (Iterator<? extends PersistentType> iter = persistenceTypes(); iter.hasNext(); ) {
			PersistentType persistentType = iter.next();
			managedTypes.put(persistentType.getMapping().getName(), buildManagedType(persistentType));
		}
		return managedTypes;
	}

	private IJPAVersion convert(JpaPlatform.Version version) {

		String jpaVersion = version.getJpaVersion();

		if (JpaFacet.VERSION_1_0.getVersionString().equals(jpaVersion)) {
			return IJPAVersion.VERSION_1_0;
		}

		return IJPAVersion.VERSION_2_0;
	}

	/**
	 * {@inheritDoc}
	 */
	public IManagedType getManagedType(IType type) {

		initializeManagedTypes();

		for (IManagedType managedType : managedTypes.values()) {
			if (managedType.getType() == type) {
				return managedType;
			}
		}

		return null;
	}

	/**
	 * {@inheritDoc}
	 */
	public IManagedType getManagedType(String abstractSchemaName) {
		initializeManagedTypes();
		return managedTypes.get(abstractSchemaName);
	}

	/**
	 * Returns the container of managed types.
	 *
	 * @return The container of managed types
	 */
	PersistentTypeContainer getPersistentTypeContainer() {
		return persistentTypeContainer;
	}

	/**
	 * {@inheritDoc}
	 */
	public IPlatform getPlatform() {
		return IPlatform.JAVA;
		// TODO
//		return (jpaProject instanceof EclipseLinkJpaProject) ? IPlatform.ECLIPSE_LINK : IPlatform.JAVA;
	}

	/**
	 * Returns the encapsulated {@link PersistentType}, which is the actual object.
	 *
	 * @return The design-time representation of a managed type provider
	 */
	PersistentTypeContainer getProvider() {
		return persistentTypeContainer;
	}

	/**
	 * {@inheritDoc}
	 */
	public JpaTypeRepository getTypeRepository() {
		if (typeRepository == null) {
			typeRepository = new JpaTypeRepository(jpaProject.getJavaProject());
		}
		return typeRepository;
	}

	/**
	 * {@inheritDoc}
	 */
	public IJPAVersion getVersion() {
		if (version == null) {
			version = convert(jpaProject.getJpaPlatform().getJpaVersion());
		}
		return version;
	}

	private void initializeManagedTypes() {
		if (managedTypes == null) {
			managedTypes = buildManagedTypes();
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public Iterable<IManagedType> managedTypes() {
		initializeManagedTypes();
		return Collections.unmodifiableCollection(managedTypes.values());
	}

	/**
	 * Retrieves the managed types from the design-time provider.
	 *
	 * @return The managed types that are defined only in the provider
	 */
	abstract Iterator<? extends PersistentType> persistenceTypes();

	private static class EntityCollector implements IManagedTypeVisitor {

		/**
		 * The collection of {@link IEntity entities} that got visited.
		 */
		private final Collection<IEntity> entities;

		/**
		 * Creates a new <code>EntityCollector</code>.
		 */
		EntityCollector() {
			super();
			entities = new ArrayList<IEntity>();
		}

		/**
		 * {@inheritDoc}
		 */
		public void visit(IEmbeddable embeddable) {
		}

		/**
		 * {@inheritDoc}
		 */
		public void visit(IEntity entity) {
			entities.add(entity);
		}

		/**
		 * {@inheritDoc}
		 */
		public void visit(IMappedSuperclass mappedSuperclass) {
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.jpa.core.context.MappedSuperclass;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeVisitor;
import org.eclipse.persistence.jpa.jpql.spi.IMappedSuperclass;

/**
 * The concrete implementation of {@link IMappedSuperclass} that is wrapping the design-time
 * representation of a JPA mapped superclass.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaMappedSuperclass extends JpaManagedType
                                implements IMappedSuperclass {

	/**
	 * Creates a new <code>JpaMappedSuperclass</code>.
	 *
	 * @param provider The provider of JPA managed types
	 * @param mappedSuperclass The design-time model object wrapped by this class
	 */
	JpaMappedSuperclass(JpaManagedTypeProvider provider, MappedSuperclass mappedSuperclass) {
		super(provider, mappedSuperclass);
	}

	/**
	 * {@inheritDoc}
	 */
	public void accept(IManagedTypeVisitor visitor) {
		visitor.visit(this);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	MappedSuperclass getManagedType() {
		return (MappedSuperclass) super.getManagedType();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.lang.annotation.Annotation;
import java.util.Iterator;
import java.util.List;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.AttributeMapping;
import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentAttribute;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IMapping;
import org.eclipse.persistence.jpa.jpql.spi.IMappingType;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;

/**
 * The concrete implementation of {@link IMapping} that is wrapping the design-time representation
 * of a mapping.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
final class JpaMapping implements IMapping {

	/**
	 * The design-time {@link AttributeMapping} wrapped by this class.
	 */
	private final AttributeMapping mapping;

	/**
	 * The type of the actual mapping.
	 */
	private IMappingType mappingType;

	/**
	 * The parent of this mapping.
	 */
	private final JpaManagedType parent;

	/**
	 * The type declaration of the property represented by the mapping.
	 */
	private ITypeDeclaration typeDeclaration;

	/**
	 * Creates a new <code>JpaMapping</code>.
	 *
	 * @param parent The parent of this mapping
	 * @param mapping The design-time {@link AttributeMapping} wrapped by this class
	 */
	JpaMapping(JpaManagedType parent, AttributeMapping mapping) {
		super();
		this.parent  = parent;
		this.mapping = mapping;
	}

	private ITypeDeclaration[] buildGenericTypeDeclarations() {
		JavaPersistentAttribute javaPersistentAttribute = mapping.getPersistentAttribute().getJavaPersistentAttribute();
		JavaResourcePersistentAttribute resource = javaPersistentAttribute.getResourcePersistentAttribute();
		List<ITypeDeclaration> declarations = CollectionTools.list(buildGenericTypeDeclarations(resource));
		return declarations.toArray(new ITypeDeclaration[declarations.size()]);
	}

	private Iterator<ITypeDeclaration> buildGenericTypeDeclarations(JavaResourcePersistentAttribute resource) {
		return new TransformationIterator<String, ITypeDeclaration>(resource.typeTypeArgumentNames()) {
			@Override
			protected ITypeDeclaration transform(String next) {
				return getTypeRepository().getType(next).getTypeDeclaration();
			}
		};
	}

	private ITypeDeclaration buildTypeDeclaration() {
		return new JpaTypeDeclaration(
			getTypeRepository().getType(mapping.getPersistentAttribute().getTypeName()),
			buildGenericTypeDeclarations(),
			false /*TODO*/
		);
	}

	/**
	 * {@inheritDoc}
	 */
	public int compareTo(IMapping mapping) {
		return getName().compareTo(mapping.getName());
	}

	/**
	 * {@inheritDoc}
	 */
	public IMappingType getMappingType() {
		if (mappingType == null) {
			mappingType = mappingType();
		}
		return mappingType;
	}

	/**
	 * {@inheritDoc}
	 */
	public String getName() {
		return mapping.getName();
	}

	/**
	 * {@inheritDoc}
	 */
	public IManagedType getParent() {
		return parent;
	}

	/**
	 * {@inheritDoc}
	 */
	public IType getType() {
		PersistentAttribute property = mapping.getPersistentAttribute();
		return getTypeRepository().getType(property.getTypeName());
	}

	/**
	 * {@inheritDoc}
	 */
	public ITypeDeclaration getTypeDeclaration() {
		if (typeDeclaration == null) {
			typeDeclaration = buildTypeDeclaration();
		}
		return typeDeclaration;
	}

	private JpaTypeRepository getTypeRepository() {
		return parent.getType().getTypeRepository();
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
		JavaResourcePersistentAttribute attribute = mapping.getPersistentAttribute().getJavaPersistentAttribute().getResourcePersistentAttribute();
		return attribute.getAnnotation(annotationType.getName()) != null;
	}

	private IMappingType mappingType() {

		String type = mapping.getKey();

		// Basic
		if (type == MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.BASIC;
		}

		// Embedded
		if (type == MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.EMBEDDED;
		}

		// Embedded Id
		if (type == MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.EMBEDDED_ID;
		}

		// Id
		if (type == MappingKeys.ID_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.ID;
		}

		// M:M
		if (type == MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.MANY_TO_MANY;
		}

		// 1:M
		if (type == MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.ONE_TO_MANY;
		}

		// M:1
		if (type == MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.MANY_TO_ONE;
		}

		// 1:1
		if (type == MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.ONE_TO_ONE;
		}

		// Version
		if (type == MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.VERSION;
		}

		// Element Collection
		if (type == MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY) {
			return IMappingType.ELEMENT_COLLECTION;
		}

		// Basic Collection
//		if (type == EclipseLinkMappingKeys.BASIC_COLLECTION_ATTRIBUTE_MAPPING_KEY) {
//			return IMappingType.BASIC_COLLECTION;
//		}
//
//		// Basic Map
//		if (type == EclipseLinkMappingKeys.BASIC_MAP_ATTRIBUTE_MAPPING_KEY) {
//			return IMappingType.BASIC_MAP;
//		}
//
//		// Transformation
//		if (type == EclipseLinkMappingKeys.TRANSFORMATION_ATTRIBUTE_MAPPING_KEY) {
//			return IMappingType.TRANSFORMATION;
//		}
//
//		// Variable 1:1
//		if (type == EclipseLinkMappingKeys.VARIABLE_ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY) {
//			return IMappingType.VARIABLE_ONE_TO_ONE;
//		}

		return IMappingType.TRANSIENT;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		StringTools.buildSimpleToStringOn(this, sb);
		sb.append("name=");
		sb.append(getName());
		sb.append(", mappingType=");
		sb.append(getMappingType());
		return sb.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.Iterator;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.MappingFile;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.TypeMapping;

/**
 * The concrete implementation that is wrapping the design-time representation of a mapping file.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
public class JpaMappingFile extends JpaManagedTypeProvider {

	/**
	 * Creates a new <code>JpaMappingFile</code>.
	 * 
	 * @param jpaProject The project that gives access to the application's metadata
	 * @param persistentTypeContainer The design-time provider of managed types
	 */
	public JpaMappingFile(JpaProject jpaProject, MappingFile persistentTypeContainer) {
		super(jpaProject, persistentTypeContainer);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	JpaEntity buildEntity(TypeMapping mappedClass) {
		return new JpaOrmEntity(this, (Entity) mappedClass);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected MappingFile getPersistentTypeContainer() {
		return (MappingFile) super.getPersistentTypeContainer();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected Iterator<? extends PersistentType> persistenceTypes() {
		return getPersistentTypeContainer().getPersistentTypes().iterator();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeProvider;
import org.eclipse.persistence.jpa.jpql.spi.IManagedTypeVisitor;
import org.eclipse.persistence.jpa.jpql.spi.IMapping;
import org.eclipse.persistence.jpa.jpql.spi.IType;

/**
 * The concrete implementation of {@link IManagedType} that is wrapping the design-time
 * representation a "null" managed type.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaNullManagedType implements IManagedType {

	/**
	 * The provider of JPA managed types.
	 */
	private final JpaManagedTypeProvider provider;

	/**
	 * The cached {@link IType} of this "null" managed type.
	 */
	private IType type;

	/**
	 * The design-time model object wrapped by this class.
	 */
	private final TypeMapping typeMapping;

	/**
	 * Creates a new <code>JpaNullManagedType</code>.
	 *
	 * @param managedType The provider of JPA managed types
	 * @param typeMapping The design-time model object wrapped by this class
	 */
	JpaNullManagedType(JpaManagedTypeProvider provider, TypeMapping typeMapping) {
		super();
		this.provider    = provider;
		this.typeMapping = typeMapping;
	}

	/**
	 * {@inheritDoc}
	 */
	public void accept(IManagedTypeVisitor visitor) {
	}

	/**
	 * {@inheritDoc}
	 */
	public int compareTo(IManagedType managedType) {
		return getType().getName().compareTo(managedType.getType().getName());
	}

	/**
	 * {@inheritDoc}
	 */
	public IMapping getMappingNamed(String name) {
		return null;
	}

	/**
	 * {@inheritDoc}
	 */
	public IManagedTypeProvider getProvider() {
		return provider;
	}

	/**
	 * {@inheritDoc}
	 */
	public IType getType() {
		if (type == null) {
			type = provider.getTypeRepository().getType(typeMapping.getPersistentType().getName());
		}
		return type;
	}

	/**
	 * {@inheritDoc}
	 */
	public Iterable<IMapping> mappings() {
		return EmptyIterable.instance();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. 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:
 *     Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.ListIterator;
import java.util.Map;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.context.java.JavaTypeMapping;
import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
import org.eclipse.persistence.jpa.jpql.spi.IQuery;

/**
 * The concrete implementation of {@link IEntity} that is wrapping the design-time representation
 * of a JPA entity defined in an ORM configuration.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaOrmEntity extends JpaEntity {

	/**
	 * Creates a new <code>JpaOrmEntity</code>.
	 *
	 * @param provider The provider of JPA managed types
	 * @param entity The design-time model object wrapped by this class
	 */
	JpaOrmEntity(JpaMappingFile provider, Entity entity) {
		super(provider, entity);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	void initializeQueries(Map<String, IQuery> queries) {
		super.initializeQueries(queries);

		JpaManagedTypeProvider provider = getProvider();
		OrmPersistentType type = (OrmPersistentType) getManagedType().getPersistentType();
		JavaTypeMapping mapping = type.getJavaPersistentType().getMapping();

		if (mapping instanceof Entity) {
			Entity entity = (Entity) mapping;
			for (ListIterator<NamedQuery> iter = entity.getQueryContainer().namedQueries(); iter.hasNext(); ) {
				NamedQuery namedQuery = iter.next();
				queries.put(namedQuery.getName(), buildQuery(provider, namedQuery));
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.Iterator;
import org.eclipse.jpt.common.utility.internal.iterators.CompositeIterator;
import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.jpt.jpa.core.context.persistence.ClassRef;
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;

/**
 * The concrete implementation that is wrapping the design-time representation of a persistence unit.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
public final class JpaPersistenceUnit extends JpaManagedTypeProvider {

	/**
	 * Creates a new <code>JpaPersistenceUnit</code>.
	 *
	 * @param jpaProject The project that gives access to the application's metadata
	 * @param persistentUnit The design-time persistence unit
	 */
	public JpaPersistenceUnit(JpaProject jpaProject, PersistenceUnit persistentUnit) {
		super(jpaProject, persistentUnit);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	JpaEntity buildEntity(TypeMapping mappedClass) {
		return new JpaPersistenceUnitEntity(this, (Entity) mappedClass);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	PersistenceUnit getPersistentTypeContainer() {
		return (PersistenceUnit) super.getPersistentTypeContainer();
	}

	@SuppressWarnings("unchecked")
	private Iterator<ClassRef> javaClassRefs() {
		return new CompositeIterator<ClassRef>(
			getPersistentTypeContainer().specifiedClassRefs(),
			getPersistentTypeContainer().impliedClassRefs()
		);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	Iterator<? extends PersistentType> persistenceTypes() {
		return new TransformationIterator<ClassRef, PersistentType>(javaClassRefs()) {
			@Override
			protected PersistentType transform(ClassRef classRef) {
				return classRef.getJavaPersistentType();
			}
		};
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. 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:
 *     Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.jpa.core.context.Entity;

/**
 * The concrete implementation of {@link IEntity} that is wrapping the design-time representation
 * of a JPA entity defined in a persistence unit.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaPersistenceUnitEntity extends JpaEntity {

	/**
	 * Creates a new <code>JpaPersistenceUnitEntity</code>.
	 *
	 * @param provider The provider of JPA managed types
	 * @param entity The design-time model object wrapped by this class
	 */
	JpaPersistenceUnitEntity(JpaManagedTypeProvider provider, Entity entity) {
		super(provider, entity);
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.persistence.jpa.jpql.spi.IQuery;

/**
 * The concrete implementation of {@link IQuery} that is wrapping the design-time representation
 * of a JPQL query.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
public final class JpaQuery implements IQuery {

	/**
	 * The actual JPQL query, which can differ from the one owned by the model object, which happens
	 * when the model is out of sync because it has not been updated yet.
	 */
	private String actualQuery;

	/**
	 *  The provider of managed types.
	 */
	private JpaManagedTypeProvider provider;

	/**
	 * The model object holding onto the JPQL query.
	 */
	private NamedQuery query;

	/**
	 * Creates a new <code>JpaQuery</code>.
	 *
	 * @param provider The provider of managed types
	 * @param query The model object of the JPQL query
	 */
	public JpaQuery(JpaManagedTypeProvider provider, NamedQuery query) {
		this(provider, query, query.getQuery());
	}

	/**
	 * Creates a new <code>JpaQuery</code>.
	 *
	 * @param provider The provider of managed types
	 * @param query The model object of the JPQL query
	 * @param actualQuery The actual JPQL query, which can differ from the one owned by the model
	 * object, which happens when the model is out of sync because it has not been updated yet
	 */
	JpaQuery(JpaManagedTypeProvider provider, NamedQuery query, String actualQuery) {
		super();
		initialize(provider, query, actualQuery);
	}

	/**
	 * {@inheritDoc}
	 */
	public String getExpression() {
		return actualQuery;
	}

	/**
	 * {@inheritDoc}
	 */
	public JpaManagedTypeProvider getProvider() {
		return provider;
	}

	/**
	 * Returns the encapsulated {@link NamedQuery}, which is the actual object.
	 *
	 * @return The design-time representation of a JPQL query
	 */
	NamedQuery getQuery() {
		return query;
	}

	private void initialize(JpaManagedTypeProvider provider, NamedQuery query, String actualQuery) {

		this.query       = query;
		this.provider    = provider;
		this.actualQuery = actualQuery;

		if (this.actualQuery == null) {
			this.actualQuery = StringTools.EMPTY_STRING;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(super.toString());
		sb.append(", query=");
		sb.append(getExpression());
		return sb.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.persistence.jpa.jpql.spi.IConstructor;
import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;

/**
 * The concrete implementation of {@link org.eclipse.persistence.jpa.query.spi.IType IType} that is
 * wrapping the design-time representation of a Java type.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaType implements org.eclipse.persistence.jpa.jpql.spi.IType {

	/**
	 * The cached collection of {@link IConstructor constructors}.
	 */
	private Collection<IConstructor> constructors;

	/**
	 * The list of names for the {@link Enum}'s constants otherwise an empty array.
	 */
	private String[] enumConstants;

	/**
	 * The actual Java type.
	 */
	private Class<?> javaType;

	/**
	 * The design-time representation of a Java type.
	 */
	private IType type;

	/**
	 * Caches the type hierarchy of the {@link IType} in order to prevent rebuilding it each time.
	 */
	private ITypeDeclaration typeDeclaration;

	/**
	 * Caches the type hierarchy of the {@link IType} in order to prevent rebuilding it each time
	 * {@link #isAssignableTo(org.eclipse.persistence.jpa.query.spi.IType)} is called.
	 */
	private ITypeHierarchy typeHierarchy;

	/**
	 * The fully qualified name of the Java type.
	 */
	private final String typeName;

	/**
	 * The external form of a type repository.
	 */
	private final JpaTypeRepository typeRepository;

	/**
	 * Creates a new <code>JpaType</code>.
	 *
	 * @param typeRepository The external form of a type repository
	 * @param javaType The actual Java type
	 */
	JpaType(JpaTypeRepository typeRepository, Class<?> javaType) {
		this(typeRepository, javaType.getName());
		this.javaType = javaType;
	}

	/**
	 * Creates a new <code>JpaType</code>.
	 *
	 * @param typeRepository The external form of a type repository
	 * @param type The design-time representation of a Java type
	 */
	JpaType(JpaTypeRepository typeRepository, IType type) {
		this(typeRepository, type.getFullyQualifiedName());
		this.type = type;
	}

	/**
	 * Creates a new <code>JpaType</code>.
	 *
	 * @param typeRepository The external form of a type repository
	 * @param typeName The fully qualified name of the Java type
	 */
	JpaType(JpaTypeRepository typeRepository, String typeName) {
		super();
		this.typeName       = typeName;
		this.typeRepository = typeRepository;
	}

	private ASTNode buildASTNode() {

		ASTParser parser = ASTParser.newParser(AST.JLS3);

		if (type.getElementType() == IJavaElement.CLASS_FILE) {
			parser.setSource(type.getClassFile());
		}
		else {
			parser.setSource(type.getTypeRoot());
		}

		parser.setIgnoreMethodBodies(true); // we don't need method bodies
		parser.setResolveBindings(true);
		parser.setBindingsRecovery(true); // see bugs 196200, 222735

		return parser.createAST(new NullProgressMonitor());
	}

	private IConstructor buildConstructor(MethodDeclaration method) {
		return new JpaConstructor(typeRepository, method);
	}

	private Collection<IConstructor> buildConstructors() {

		if (type == null) {
			return Collections.emptyList();
		}

		final Collection<IConstructor> constructors = new ArrayList<IConstructor>();
		ASTNode astNode = buildASTNode();

		astNode.accept(new ASTVisitor() {
			@Override
			public boolean visit(MethodDeclaration node) {
				if (node.isConstructor()) {
					constructors.add(buildConstructor(node));
				}
				return true;
			}
		});

		return constructors;
	}

	private String[] buildEnumConstants() {

		try {
			if ((type != null) && type.isEnum()) {

				List<String> names = new ArrayList<String>();

				for (IField field : type.getFields()) {
					if (field.isEnumConstant()) {
						names.add(field.getElementName());
					}
				}

				return names.toArray(new String[names.size()]);
			}
		}
		catch (Exception e) {
			// Just ignore and return an empty array
		}

		return ExpressionTools.EMPTY_STRING_ARRAY;
	}

	private ITypeDeclaration buildTypeDeclaration() {
		return new JpaTypeDeclaration(this, new ITypeDeclaration[0], false);
	}

	/**
	 * {@inheritDoc}
	 */
	public Iterable<IConstructor> constructors() {
		if (constructors == null) {
			constructors = buildConstructors();
		}
		return Collections.unmodifiableCollection(constructors);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public boolean equals(Object object) {
		return (this == object) || equals((org.eclipse.persistence.jpa.jpql.spi.IType) object);
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean equals(org.eclipse.persistence.jpa.jpql.spi.IType type) {
		return (this == type) || typeName.equals(type.getName());
	}

	/**
	 * {@inheritDoc}
	 */
	public String[] getEnumConstants() {
		if (enumConstants == null) {
			enumConstants = buildEnumConstants();
		}
		return enumConstants;
	}

	/**
	 * Returns the encapsulated Java {@link Class}, which is the actual type.
	 *
	 * @return The actual Java type
	 */
	Class<?> getJavaType() {
		return javaType;
	}

	/**
	 * {@inheritDoc}
	 */
	public String getName() {
		return typeName;
	}

	/**
	 * Returns the encapsulated {@link Type}, which is the actual type.
	 *
	 * @return The design-time representation of a Java type
	 */
	IType getType() {
		return type;
	}

	/**
	 * {@inheritDoc}
	 */
	public ITypeDeclaration getTypeDeclaration() {
		if (typeDeclaration == null) {
			typeDeclaration = buildTypeDeclaration();
		}
		return typeDeclaration;
	}

	/**
	 * Returns the repository that gives access to the application's classes.
	 *
	 * @return The external form of the type repository
	 */
	JpaTypeRepository getTypeRepository() {
		return typeRepository;
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean hasAnnotation(Class<? extends Annotation> annotationType) {

		if (type != null) {
			return type.getAnnotation(annotationType.getName()) != null;
		}

		if (javaType != null) {
			return javaType.isAnnotationPresent(annotationType);
		}

		return false;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public int hashCode() {
		return typeName.hashCode();
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean isAssignableTo(org.eclipse.persistence.jpa.jpql.spi.IType type) {

		if (this == type) {
			return true;
		}

		JpaType jpaType = (JpaType) type;

		// Dealing with two IType
		if ((this.type != null) && (jpaType.type != null)) {
			try {
				// TODO: Use ASTTools.typeIsSubTypeOf() instead
				if (typeHierarchy == null) {
					typeHierarchy = this.type.newTypeHierarchy(new NullProgressMonitor());
				}
				return typeHierarchy.contains(jpaType.type);
			}
			catch (Exception e) {
				return false;
			}
		}

		// Dealing with two Class<?>
		if ((javaType != null) && (jpaType.javaType != null)) {
			return jpaType.javaType.isAssignableFrom(javaType);
		}

		// Anything else is always false
		return false;
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean isEnum() {

		if (javaType != null) {
			return javaType.isEnum();
		}

		try {
			return (type != null) ? type.isEnum() : false;
		}
		catch (Exception e) {
			// Simply ignore and return no
			return false;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean isResolvable() {
		return (type != null) || (javaType != null);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public String toString() {
		return StringTools.buildToStringFor(this, typeName);
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;

/**
 * The concrete implementation of {@link ITypeDeclaration} that is wrapping the design-time
 * representation of the declaration description of a type.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpaTypeDeclaration implements ITypeDeclaration {

	/**
	 * Determines whether this type represents an array or not.
	 */
	private boolean array;

	/**
	 * The generics of the given type or an empty list if the type is not parameterized.
	 */
	private final ITypeDeclaration[] genericTypes;

	/**
	 * The external form of the Java type.
	 */
	private final IType type;

	/**
	 * Creates a new <code>JpaTypeDeclaration</code>.
	 *
	 * @param type The external form of the Java type
	 * @param genericTypes The generics of the given type or an empty list if the type is not
	 * parameterized
	 * @param array Determines whether this type represents an array or not
	 */
	JpaTypeDeclaration(IType type, ITypeDeclaration[] genericTypes, boolean array) {
		super();
		this.type         = type;
		this.genericTypes = genericTypes;
		this.array        = array;
	}

	/**
	 * {@inheritDoc}
	 */
	public int getDimensionality() {
		return array ? 1 : 0; // TODO
	}

	/**
	 * {@inheritDoc}
	 */
	public IType getType() {
		return type;
	}

	/**
	 * {@inheritDoc}
	 */
	public ITypeDeclaration[] getTypeParameters() {
		return genericTypes;
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean isArray() {
		return array;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public String toString() {
		return type.getName();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpql;

import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.persistence.jpa.jpql.TypeHelper;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;

/**
 * The concrete implementation of {@link ITypeRepository} that is wrapping the design-time
 * representation of a type repository.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
final class JpaTypeRepository implements ITypeRepository {

	/**
	 * The Java project that gives access the design-time objects representing the Java types.
	 */
	private final IJavaProject javaProject;

	/**
	 * Keeps a map of the primitives for fast access.
	 */
	private Map<String, Class<?>> primitives;

	/**
	 * The cached helper that is using this repository for retrieving {@link IType types}.
	 */
	private TypeHelper typeHelper;

	/**
	 * The types that have been cached for faster access.
	 */
	private final Map<String, JpaType> types;

	/**
	 * The {@link IType} that represents a unresolvable or simply an unknown type, which is created
	 * when {@link #getType(String)} is invoked with {@link IType#UNRESOLVABLE_TYPE}.
	 */
	private JpaType unresolvableType;

	/**
	 * Creates a new <code>JpaTypeRepository</code>.
	 *
	 * @param javaProject The Java project that gives access the design-time objects representing
	 * the Java types
	 */
	JpaTypeRepository(IJavaProject javaProject) {
		super();
		this.javaProject = javaProject;
		this.types       = new HashMap<String, JpaType>();
	}

	private Map<String, Class<?>> buildPrimitives() {
		Map<String, Class<?>> primitives = new HashMap<String, Class<?>>();
		primitives.put(Byte     .TYPE.getName(), Byte     .TYPE);
		primitives.put(Short    .TYPE.getName(), Short    .TYPE);
		primitives.put(Character.TYPE.getName(), Character.TYPE);
		primitives.put(Integer  .TYPE.getName(), Integer  .TYPE);
		primitives.put(Long     .TYPE.getName(), Long     .TYPE);
		primitives.put(Float    .TYPE.getName(), Float    .TYPE);
		primitives.put(Double   .TYPE.getName(), Double   .TYPE);
		primitives.put(Boolean  .TYPE.getName(), Boolean  .TYPE);
		return primitives;
	}

	private JpaType buildType(Class<?> javaType) {
		JpaType jpaType = new JpaType(this, javaType);
		types.put(jpaType.getName(), jpaType);
		return jpaType;
	}

	private JpaType buildType(org.eclipse.jdt.core.IType type) {
		JpaType jpaType = new JpaType(this, type);
		types.put(jpaType.getName(), jpaType);
		return jpaType;
	}

	private JpaType buildType(String typeName) {
		return new JpaType(this, typeName);
	}

	private Class<?> findPrimitive(String typeName) {
		if (primitives == null) {
			primitives = buildPrimitives();
		}
		return primitives.get(typeName);
	}

	/**
	 * Retrieves the design-time Java type for the given type name, which has to be the fully
	 * qualified type name.
	 *
	 * @param typeName The fully qualified type name
	 * @return The design-time Java type if it could be retrieved; <code>null</code> otherwise
	 */
	private org.eclipse.jdt.core.IType findType(String typeName) {
		try {
			return javaProject.findType(typeName);
		}
		catch (JavaModelException e) {
			return null;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public JpaType getEnumType(String enumTypeName) {

		// Get the position of the last dot so we can remove the constant
		int lastDotIndex = enumTypeName.lastIndexOf(".");

		if (lastDotIndex == -1) {
			return null;
		}

		// Retrieve the fully qualified enum type name
		String typeName = enumTypeName.substring(0, lastDotIndex);

		// Attempt to load the enum type
		JpaType type = getType(typeName);
		return type.isEnum() ? type: null;
	}

	/**
	 * Returns
	 *
	 * @return
	 */
	IJavaProject getJavaProject() {
		return javaProject;
	}

	/**
	 * {@inheritDoc}
	 */
	public JpaType getType(Class<?> javaClass) {
		return getType(javaClass.getName());
	}

	/**
	 * Retrieves the {@link org.eclipse.jdt.core.IType IType} for the given {@link IResource}.
	 *
	 * @param resource The workspace location of the {@link org.eclipse.jdt.core.IType IType} to
	 * retrieve
	 * @return The design-time representation of a Java type
	 */
	org.eclipse.jdt.core.IType getType(IResource resource) {
		try {
			return (org.eclipse.jdt.core.IType) javaProject.findElement((IPath) resource);
		}
		catch (Exception e) {
			return null;
		}
	}

	/**
	 * Retrieves the {@link org.eclipse.jdt.core.IType IType} for the given {@link IResource}.
	 *
	 * @param resource The workspace location of the {@link org.eclipse.jdt.core.IType IType} to
	 * retrieve
	 * @return The design-time representation of a Java type
	 */
	IType getType(org.eclipse.jdt.core.IType type) {
		try {
			IType jpaType = types.get(type.getFullyQualifiedName());
			if (jpaType == null) {
				jpaType = buildType(type);
			}
			return jpaType;
		}
		catch (Exception e) {
			return null;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public JpaType getType(String typeName) {

		if (IType.UNRESOLVABLE_TYPE == typeName) {
			return unresolvableType();
		}

		if (typeName.charAt(0) == '[') {
			return loadArrayType(typeName);
		}

		return loadTypeImp(typeName);
	}

	/**
	 * {@inheritDoc}
	 */
	public TypeHelper getTypeHelper() {
		if (typeHelper == null) {
			typeHelper = new TypeHelper(this);
		}
		return typeHelper;
	}

	private JpaType loadArrayType(String typeName) {

		JpaType type = types.get(typeName);

		if (type == null) {
			try {
				// Try to see if the type is a JDK class, otherwise, just use the type name
				// since IType doesn't support array types
				type = buildType(Class.forName(typeName));
			}
			catch (Exception e) {
				type = buildType(typeName);
			}

			types.put(typeName, type);
		}

		return type;
	}

	private JpaType loadInnerType(String typeName) {

		int index = typeName.lastIndexOf(".");

		if (index == -1) {
			return null;
		}

		StringBuilder sb = new StringBuilder();
		sb.append(typeName.substring(0, index));
		sb.append("$");
		sb.append(typeName.substring(index + 1, typeName.length()));
		typeName = sb.toString();

		JpaType type = types.get(typeName);

		if (type == null) {
			type = loadTypeImp(typeName);
		}

		return type;
	}

	private JpaType loadTypeImp(String typeName) {

		JpaType type = types.get(typeName);

		// The type was already cached, simply return it
		if (type != null) {
			return type;
		}

		// First check for primitive, they don't have a corresponding IType
		Class<?> primitive = findPrimitive(typeName);

		if (primitive != null) {
			return buildType(primitive);
		}

		// Attempt to load the Java type
		org.eclipse.jdt.core.IType iType = findType(typeName);

		// A Java type exists, return it
		if (iType != null) {
			return buildType(iType);
		}

		// Now try with a possible inner enum type
		type = loadInnerType(typeName);

		// No Java type exists, create a "null" IType
		if (type == null) {
			type = buildType(typeName);
		}

		return type;
	}

	private JpaType unresolvableType() {
		if (unresolvableType == null) {
			unresolvableType = new JpaType(this, IType.UNRESOLVABLE_TYPE);
		}
		return unresolvableType;
	}
}




 * 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/

public interface JpaValidationMessages {

	public static final String BUNDLE_NAME = "jpa_validation";

	public static final String PROJECT_INVALID_LIBRARY_PROVIDER = "PROJECT_INVALID_LIBRARY_PROVIDER";
	public static final String PROJECT_NO_CONNECTION = "PROJECT_NO_CONNECTION";
	public static final String PROJECT_INVALID_CONNECTION = "PROJECT_INVALID_CONNECTION";

	public static final String GENERATOR_NAME_UNDEFINED = "GENERATOR_NAME_UNDEFINED";
	public static final String QUERY_DUPLICATE_NAME = "QUERY_DUPLICATE_NAME";
	public static final String QUERY_NAME_UNDEFINED = "QUERY_NAME_UNDEFINED";
	public static final String JPQL_QUERY_VALIDATION = "JPQL_QUERY_VALIDATION";
	public static final String QUERY_STATEMENT_UNDEFINED = "QUERY_STATEMENT_UNDEFINED";
	public static final String MAPPING_FILE_EXTRANEOUS_PERSISTENCE_UNIT_METADATA = "MAPPING_FILE_EXTRANEOUS_PERSISTENCE_UNIT_METADATA";
	public static final String PERSISTENT_TYPE_MAPPED_BUT_NOT_INCLUDED_IN_PERSISTENCE_UNIT = "PERSISTENT_TYPE_MAPPED_BUT_NOT_INCLUDED_IN_PERSISTENCE_UNIT";

	public static final String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_NAME = "VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_NAME";
	public static final String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_CATALOG = "VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_CATALOG";
	public static final String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_SCHEMA = "VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_SCHEMA";

	public static final String GENERATED_VALUE_UNRESOLVED_GENERATOR = "GENERATED_VALUE_UNRESOLVED_GENERATOR";
	public static final String PRIMARY_KEY_JOIN_COLUMN_UNRESOLVED_NAME = "PRIMARY_KEY_JOIN_COLUMN_UNRESOLVED_NAME";
	public static final String PRIMARY_KEY_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS = "PRIMARY_KEY_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS";

	public static final String VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_UNRESOLVED_REFERENCED_COLUMN_NAME = "VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_UNRESOLVED_REFERENCED_COLUMN_NAME";
	public static final String VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS = "VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS";
	public static final String VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS = "VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS";

	public static final String NO_JPA_PROJECT = "NO_JPA_PROJECT";
	public static final String TARGET_ENTITY_NOT_DEFINED = "TARGET_ENTITY_NOT_DEFINED";
	public static final String VIRTUAL_ATTRIBUTE_TARGET_ENTITY_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_TARGET_ENTITY_NOT_DEFINED";

	public static final String ENTITY_TABLE_PER_CLASS_NOT_SUPPORTED_ON_PLATFORM = "ENTITY_TABLE_PER_CLASS_NOT_SUPPORTED_ON_PLATFORM";
	public static final String ENTITY_TABLE_PER_CLASS_NOT_PORTABLE_ON_PLATFORM = "ENTITY_TABLE_PER_CLASS_NOT_PORTABLE_ON_PLATFORM";
	public static final String TARGET_NOT_AN_EMBEDDABLE = "TARGET_NOT_AN_EMBEDDABLE";

	public static final String COLUMN_TABLE_NOT_VALID="COLUMN_TABLE_NOT_VALID";
	public static final String VIRTUAL_ATTRIBUTE_COLUMN_TABLE_NOT_VALID="VIRTUAL_ATTRIBUTE_COLUMN_TABLE_NOT_VALID";
	public static final String VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID="VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID";

	public static final String VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID="VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID";
	public static final String MAP_KEY_COLUMN_TABLE_NOT_VALID="MAP_KEY_COLUMN_TABLE_NOT_VALID";
	public static final String VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID="VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID";
}
}




 * 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Named Native Query</b></em>'.
 *
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from

		result.append(')');
		return result.toString();
	}

	public TextRange getNameTextRange() {
		return getAttributeTextRange(JPA.NAME);
	}

	public TextRange getQueryTextRange() {
		return getAttributeTextRange(JPA.QUERY);
	}

	// ********** translators **********

	public static Translator buildTranslator(String elementName, EStructuralFeature structuralFeature) {

	protected static Translator buildNameTranslator() {
		return new Translator(JPA.NAME, OrmPackage.eINSTANCE.getXmlQuery_Name(), Translator.DOM_ATTRIBUTE);
	}

	protected static Translator buildResultClassTranslator() {
		return new Translator(JPA.RESULT_CLASS, OrmPackage.eINSTANCE.getXmlNamedNativeQuery_ResultClass(), Translator.DOM_ATTRIBUTE);
	}

	protected static Translator buildResultSetMappingTranslator() {
		return new Translator(JPA.RESULT_SET_MAPPING, OrmPackage.eINSTANCE.getXmlNamedNativeQuery_ResultSetMapping(), Translator.DOM_ATTRIBUTE);
	}

	protected static Translator buildDescriptionTranslator() {
		return new Translator(JPA2_0.DESCRIPTION, OrmV2_0Package.eINSTANCE.getXmlQuery_2_0_Description());
	}

	protected static Translator buildQueryTranslator() {
		return new Translator(JPA.QUERY, OrmPackage.eINSTANCE.getXmlQuery_Query());
	}

	protected static Translator buildHintTranslator() {
		return XmlQueryHint.buildTranslator(JPA.HINT, OrmPackage.eINSTANCE.getXmlQuery_Hints());
	}




 * 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.jpt.common.core.internal.utility.SimpleTextRange;
import org.eclipse.jpt.common.core.internal.utility.translators.SimpleTranslator;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.jpa.core.resource.orm.v2_0.JPA2_0;

import org.eclipse.jpt.jpa.core.resource.orm.v2_0.XmlNamedQuery_2_0;
import org.eclipse.jpt.jpa.core.resource.xml.AbstractJpaEObject;
import org.eclipse.wst.common.internal.emf.resource.Translator;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Named Query</b></em>'.
 *
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from

		result.append(')');
		return result.toString();
	}

	public TextRange getNameTextRange() {
		return getAttributeTextRange(JPA.NAME);
	}

	public TextRange getQueryTextRange() {
		// <named-query>
		IDOMNode node = getElementNode(JPA.QUERY);
		if (node != null) {
			// The query element has text
			if (node.hasChildNodes()) {
				return buildTextRange((IDOMNode) node.getFirstChild());
			}
			// The query element does not have text
			TextRange textRange = buildTextRange(node);
			return new SimpleTextRange(
				node.getEndStructuredDocumentRegion().getStartOffset(),
				0,
				textRange.getLineNumber()
			);
		}

		return this.getValidationTextRange();
	}

	// ********** translators **********

	public static Translator buildTranslator(String elementName, EStructuralFeature structuralFeature) {

	protected static Translator buildNameTranslator() {
		return new Translator(JPA.NAME, OrmPackage.eINSTANCE.getXmlQuery_Name(), Translator.DOM_ATTRIBUTE);
	}

	protected static Translator buildDescriptionTranslator() {
		return new Translator(JPA2_0.DESCRIPTION, OrmV2_0Package.eINSTANCE.getXmlQuery_2_0_Description());
	}

	protected static Translator buildQueryTranslator() {
		return new Translator(JPA.QUERY, OrmPackage.eINSTANCE.getXmlQuery_Query());
	}

	protected static Translator buildLockModeTranslator() {
		return new Translator(JPA2_0.NAMED_QUERY__LOCK_MODE, OrmV2_0Package.eINSTANCE.getXmlNamedQuery_2_0_LockMode());
	}

Lines 3-9 Link Here

(-)src/org/eclipse/jpt/jpa/core/resource/orm/XmlQuery.java (-4 / +6 lines)
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
Lines 16-22 Link Here
16	/**	16	/**
17	* <!-- begin-user-doc -->	17	* <!-- begin-user-doc -->
18	* A representation of the model object '<em><b>Query</b></em>'.	18	* A representation of the model object '<em><b>Query</b></em>'.
19	*	19	*
20	* Provisional API: This interface is part of an interim API that is still	20	* Provisional API: This interface is part of an interim API that is still
21	* under development and expected to change significantly before reaching	21	* under development and expected to change significantly before reaching
22	* stability. It is available at this early stage to solicit feedback from	22	* stability. It is available at this early stage to solicit feedback from
Lines 106-111 Link Here
106	* @generated	106	* @generated
107	*/	107	*/
108	EList<XmlQueryHint> getHints();	108	EList<XmlQueryHint> getHints();
109		109
110	public TextRange getNameTextRange();	110	TextRange getNameTextRange();
		111
		112	TextRange getQueryTextRange();
111	}	113	}




<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.2"?>
<!--
  Copyright (c) 2007, 2011 Oracle. 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.

			<partition type="__dftl_partition_content_type"/>
			<partition type="__java_string"/>
		</javaCompletionProposalComputer>

	</extension>

	
	<extension
		point="org.eclipse.jdt.ui.javaCompletionProposalComputer"
		id="jpaProposalCategory"

		<proposalCategory
			icon="$nl$/icons/full/eview16/jpa_perspective.gif"/>
	</extension>

	<extension
		point="org.eclipse.jdt.ui.javaCompletionProposalComputer"
		id="JpaJpqlCompletionProposalComputer">

		<javaCompletionProposalComputer
        activate="true"
        categoryId="org.eclipse.jpt.jpa.ui.jpaProposalCategory"
        class="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlJavaCompletionProposalComputer">
			<partition type="__dftl_partition_content_type"/>
			<partition type="__java_string"/>
		</javaCompletionProposalComputer>
		
	</extension>

	 <extension
	       id="JpaJpqlSseCompletionProposal"
	       point="org.eclipse.wst.sse.ui.completionProposal">
	    <proposalComputer
	          activate="true"
	          categoryId="org.eclipse.wst.xml.ui.proposalCategory.xmlTags"
	          class="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlSseCompletionProposalComputer"
	          id="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlSseCompletionProposalComputer">
	       <contentType
	             id="org.eclipse.jpt.jpa.core.content.orm">
	       </contentType>
	    </proposalComputer>
	 </extension>	


	<extension
		point="org.eclipse.jpt.jpa.ui.jpaPlatformUis">
		

			id="generic2_0.ui"
			jpaPlatform="generic2_0"
			factoryClass="org.eclipse.jpt.jpa.ui.internal.jpa2.platform.generic.Generic2_0JpaPlatformUiFactory"/>
	
	</extension>
  	
	

Lines 126-131 Link Here

(-)property_files/jpt_ui.properties (+4 lines)
126	JpaProblemSeveritiesPage_Info=Info	126	JpaProblemSeveritiesPage_Info=Info
127	JpaProblemSeveritiesPage_Warning=Warning	127	JpaProblemSeveritiesPage_Warning=Warning
128		128
		129	JpqlContentProposalProvider_Description=Content Assist Available ({0})
		130	JpaJpqlJavaCompletionProposalComputer_Error=Can't retrieve JPQL proposals due to an internal error.
		131	JpaJpqlSseCompletionProposalComputer_Error=Can't retrieve JPQL proposals due to an internal error.
		132
129	MappingFileWizard_title=New Mapping File	133	MappingFileWizard_title=New Mapping File
130	MappingFileWizardPage_newFile_title=Mapping file	134	MappingFileWizardPage_newFile_title=Mapping file
131	MappingFileWizardPage_newFile_desc=Specify mapping file name and location	135	MappingFileWizardPage_newFile_desc=Specify mapping file name and location




################################################################################
# Copyright (c) 2011 Oracle. 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:
#     Oracle - initial API and implementation
################################################################################

# JPA 1.0 identifiers
ABS=The <b>ABS</b> function removes the minus sign from a specified numeric argument and returns the absolute value (integer, float, or double) of the same type as the argument to the function, which is always a positive number or zero.
ALL=<ul><li>An <b>ALL</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for all values in the result of the subquery or the result of the subquery is empty.</li><li>An <b>ALL</b> conditional expression is <code>false</code> if the result of the comparison is <code>false</code> for at least one row, and is unknown if neither <code>true</code> nor <code>false</code>.</ul><p><p>The comparison operators used with <b>ALL</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
#AND
ANY=<ul><li>An <b>ANY</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for some value in the result of the subquery.</li><li>An <b>ANY</b> conditional expression is <code>false</code> if the result of the subquery is empty or if the comparison operation is <code>false</code> for every value in the result of the subquery,</li><li>and is unknown if neither <code>true</code> nor <code>false</code>.</li></ul><p><p>The comparison operators used with <b>ANY</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
ASC=The keyword <b>ASC</b> specifies that ascending ordering be used for the associated order by item.
AVG=One of the aggregate functions. The arguments must be numeric. <b>AVG</b> returns <code>Double</code>.<p><p><b>BNF:</b> <code>expression ::= AVG([DISTINCT] state_field_path_expression)</code>
BETWEEN=Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values. Numeric, string and date expression can be evaluated in this way.
BOTH=Trim from both ends.
CONCAT=The <b>CONCAT</b> function returns a string that is a concatenation of its arguments.
COUNT=One of the aggregate functions. The return type of this function is a <code>Long</code>.
CURRENT_DATE=This function returns the value of current date on the database server.
CURRENT_TIME=This function returns the value of current time on the database server.
CURRENT_TIMESTAMP=This function returns the value of current timestamp on the database
DELETE_FROM=A delete statement provide bulk operations over sets of entities.
DESC=The keyword <b>DESC</b> specifies that descending ordering be used. Ascending ordering is the default.
DISTINCT=The <b>DISTINCT</b> keyword is used to specify that duplicate values must be eliminated from the query result. If <b>DISTINCT</b> is not specified, duplicate values are not eliminated.
ESCAPE=The optional <code>escape character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character) and is used to escape the special meaning of the underscore and percent characters in <code>pattern value</code>.
EXISTS=An <b>EXISTS</b> expression is a predicate that is <code>true</code> only if the result of the subquery consists of one or more values and that is <code>false</code> otherwise.
FROM=The <b>FROM</b> clause of a query defines the domain of the query by declaring identification variables. An identification variable is an identifier declared in the <b>FROM</b> clause of a query. The domain of the query may be constrained by path expressions. Identification variables designate instances of a particular entity abstract schema type. The <b>FROM</b> clause can contain multiple identification variable declarations separated by a comma (,).
GROUP_BY=The <b>GROUP BY</b> construct enables the aggregation of values according to the properties of an entity class.
HAVING=The <b>HAVING</b> construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
IN=An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression. Such a path expression represents a navigation involving the association-fields of an entity abstract schema type. Because a path expression can be based on another path expression, the navigation can use the association-fields of related entities. An identification variable of a collection member declaration is declared using a special operator, the reserved identifier <b>IN</b>. The argument to the <b>IN</b> operator is a collection-valued path expression. The path expression evaluates to a collection type specified as a result of navigation to a collection-valued association-field of an entity abstract schema type.
IS_EMPTY=An <b>EMPTY</b> expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
IS_NULL=A null comparison tests whether or not the single-valued path expression or input parameter is a <b>NULL</b> value.
JOIN=A <b>JOIN</b> enables the fetching of an association as a side effect of the execution of a query. A <b>JOIN</b> is specified over an entity and its related entities.
JOIN_FETCH=A <b>JOIN FETCH</b> enables the fetching of an association as a side effect of the execution of a query. A <b>JOIN FETCH</b> is specified over an entity and its related entities.
LEADING=Trim from leading end.
LENGTH=The <b>LENGTH</b> function returns the length of the string in characters as an integer.
LIKE=The <b>LIKE</b> condition is used to specify a search for a pattern.<p><p>The <code>string_expression</code> must have a string value. The <code>pattern_value</code> is a string literal or a string-valued input parameter in which an underscore (_) stands for any single character, a percent (%) character stands for any sequence of characters (including the empty sequence), and all other characters stand for themselves. The optional <code>escape_character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character) and is used to escape the special meaning of the underscore and percent characters in <code>pattern_value</code>.
LOCATE=The <b>LOCATE</b> function returns the position of a given string within a string, starting the search at a specified position. It returns the first position at which the string was found as an integer. The first argument is the string to be located; the second argument is the string to be searched; the optional third argument is an integer that represents the string position at which the search is started (by default, the beginning of the string to be searched). The first position in a string is denoted by 1. If the string is not found, 0 is returned. The <b>LENGTH</b> function returns the length of the string in characters as an integer.
LOWER=The <b>LOWER</b> function converts a string to lower case and it returns a string.
MAX=One of the aggregate functions. The arguments must correspond to orderable state-field types (i.e., numeric types, string types, character types, or date types). The return type of this function is based on the state-field's type.
MEMBER=This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression. If the collection-valued path expression designates an empty collection, the value of the <b>MEMBER OF</b> expression is <b>FALSE</b> and the value of the <b>NOT MEMBER OF</b> expression is <b>TRUE</b>. Otherwise, if the value of the collection-valued path expression or single-valued association-field path expression in the collection member expression is <b>NULL</b> or unknown, the value of the collection member expression is unknown.
MIN= One of the aggregate functions. The arguments must correspond to orderable state-field types (i.e., numeric types, string types, character types, or date types). The return type of this function is based on the state-field's type.
MOD=The modulo operation finds the remainder of division of one number by another. It takes two integer arguments and returns an integer.
NEW=In the <b>SELECT</b> clause a constructor may be used in the <b>SELECT</b> list to return one or more Java instances. The specified class is not required to be an entity or to be mapped to the database. The constructor name must be fully qualified.
OBJECT=Stand-alone identification variables in the <b>SELECT</b> clause may optionally be qualified by the <b>OBJECT</b> operator. The <b>SELECT</b> clause must not use the <b>OBJECT</b> operator to qualify path expressions.
#OR
ORDER_BY=The <b>ORDER BY</b> clause allows the objects or values that are returned by the query to be ordered.
SELECT=The <b>SELECT</b> clause determines the type of the objects or values to be selected.
SIZE=The <b>SIZE</b> function returns an integer value, the number of elements of the collection. If the collection is empty, the <b>SIZE</b> function evaluates to zero.
SOME=<ul><li>An <b>SOME</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for some value in the result of the subquery.</li><li>A <b>SOME</b> conditional expression is <code>false</code> if the result of the subquery is empty or if the comparison operation is <code>false</code> for every value in the result of the subquery,</li><li>and is unknown if neither <code>true</code> nor <code>false</code>.</li></ul><p><p>The comparison operators used with <b>SOME</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
SQRT=The <b>SQRT</b> function takes a numeric argument and returns a double.
SUBSTRING=The second and third arguments of the <b>SUBSTRING</b> function denote the starting position and length of the substring to be returned. These arguments are integers. The first position of a string is denoted by 1. The <b>SUBSTRING</b> function returns a string.
SUM= One of the aggregate functions. The arguments must be numeric. The <b>SUM</b> function returns <code>Long</code> when applied to state-fields of integral types (other than <code>BigInteger</code>); <code>Double</code> when applied to state-fields of floating point types; <code>BigInteger</code> when applied to state-fields of type <code>BigInteger</code>; and <code>BigDecimal</code> when applied to state-fields of type <code>BigDecimal</code>. If <b>SUM</b>, <b>AVG</b>, <b>MAX</b>, or <b>MIN</b> is used, and there are no values to which the aggregate function can be applied, the result of the aggregate function is <code>NULL</code>. If <code>COUNT</code> is used, and there are no values to which <b>COUNT</b> can be applied, the result of the aggregate function is 0.
TRAILING=Trim from trailing end.
TRIM=The <b>TRIM</b> function trims the specified character from a string. If the character to be trimmed is not specified, it is assumed to be space (or blank). The optional <code>trim_character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character). If a trim specification is not provided, <b>BOTH</b> is assumed. The <b>TRIM</b> function returns the trimmed string.
UPDATE=An update statement provide bulk operations over sets of entities.
UPPER=The <b>UPPER</b> function converts a string to upper case and it returns a string.
WHERE=The <b>WHERE</b> clause of a query consists of a conditional expression used to select objects or values that satisfy the expression. The <b>WHERE</b> clause restricts the result of a select statement or the scope of an update or delete operation.

# JPA 2.0 identifiers
#CASE=
COALESCE=A <b>COALESCE</b> expression returns <code>null</code> if all its arguments evaluate to <code>null</code>, and the value of the first non-<code>null</code> argument otherwise.<p><p>The return type is the type returned by the arguments if they are all of the same type, otherwise it is undetermined.
#ENTRY=
INDEX=The <b>INDEX</b> function returns an integer value corresponding to the position of its argument in an ordered list. The <b>INDEX</b> function can only be applied to identification variables denoting types for which an order column has been specified.
#KEY=
NULLIF=<b>NULLIF</b> returns the first expression if the two expressions are not equal. If the expressions are equal, <b>NULLIF</b> returns a null value of the type of the first expression.<p><p><b>NULLIF</b> is equivalent to a searched <b>CASE</b> expression in which the two expressions are equal and the resulting expression is <b>NULL</b>.<p><p>Returns the same type as the first expression.
TYPE=An entity type expression can be used to restrict query polymorphism. The <b>TYPE</b> operator returns the exact type of the argument.
#VALUE=

# EclipseLink identifiers
#FUNC=
#TREAT=

# Reserved JPQL identifiers
BIT_LENGTH=The identifier <b>BIT_LENGTH</b> is not currently used: it is reserved for future use.
CHAR_LENGTH=The identifier <b>CHAR_LENGTH</b> is not currently used: it is reserved for future use.
CHARACTER_LENGTH=The identifier <b>CHARACTER_LENGTH</b> is not currently used: it is reserved for future use.
CLASS=The identifier <b>CLASS</b> is not currently used: it is reserved for future use.
POSITION=The identifier <b>POSITION</b> is not currently used: it is reserved for future use.
UNKNOWN=The identifier <b>UNKNOWN</b> is not currently used: it is reserved for future use.

Lines 209-211 Link Here

(-)property_files/jpt_ui_validation_preferences.properties (+1 lines)
209	ID_MAPPING_UNRESOLVED_GENERATOR_NAME=Unresolved generator name:	209	ID_MAPPING_UNRESOLVED_GENERATOR_NAME=Unresolved generator name:
210	GENERATED_VALUE_UNRESOLVED_GENERATOR=Generator is not defined in the persistence unit:	210	GENERATED_VALUE_UNRESOLVED_GENERATOR=Generator is not defined in the persistence unit:
211	QUERY_DUPLICATE_NAME=Duplicate query defined:	211	QUERY_DUPLICATE_NAME=Duplicate query defined:
		212	JPQL_QUERY_VALIDATION=Invalid or incomplete JPQL queries:




	public static final String TRANSIENT = "full/obj16/transient";
	
	public static final String NULL_ATTRIBUTE_MAPPING = "full/obj16/null-attribute-mapping";


	// **************** Content Assist icons **********************************

	public static final String JPQL_FUNCTION = "full/obj16/jpql.function";

	public static final String JPQL_IDENTIFIER = "full/obj16/jpql.identifier";

	public static final String JPQL_VARIABLE = "full/obj16/jpql.variable";
}




/*******************************************************************************
 * Copyright (c) 2009, 2011 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/

	public static String PROJECT_INVALID_CONNECTION;
	public static String PROJECT_INACTIVE_CONNECTION;
	public static String PROJECT_NO_PERSISTENCE_XML;

	public static String XML_VERSION_NOT_LATEST;

	public static String PROJECT_MULTIPLE_PERSISTENCE_XML;
	public static String PERSISTENCE_NO_PERSISTENCE_UNIT;
	public static String PERSISTENCE_MULTIPLE_PERSISTENCE_UNITS;

	public static String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED;
	public static String ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE;
	public static String ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED;

	public static String DATABASE_CATEGORY;
	public static String TABLE_CATEGORY;
	public static String COLUMN_CATEGORY;
	public static String OVERRIDES_CATEGORY;
	public static String IMPLIED_ATTRIBUTE_LEVEL_CATEGORY;

	public static String TABLE_UNRESOLVED_CATALOG;
	public static String TABLE_UNRESOLVED_SCHEMA;
	public static String TABLE_UNRESOLVED_NAME;

	public static String VIRTUAL_SECONDARY_TABLE_PRIMARY_KEY_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS;
	public static String MAP_KEY_COLUMN_TABLE_NOT_VALID;
	public static String VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID;

	public static String COLLECTION_TABLE_UNRESOLVED_CATALOG;
	public static String COLLECTION_TABLE_UNRESOLVED_SCHEMA;
	public static String COLLECTION_TABLE_UNRESOLVED_NAME;
	public static String ORDER_COLUMN_UNRESOLVED_NAME;

	public static String VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_CATALOG;
	public static String VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_SCHEMA;
	public static String VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_NAME;

	public static String VIRTUAL_ATTRIBUTE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS;
	public static String VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID;
	public static String VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID;

	public static String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_CATALOG;
	public static String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_SCHEMA;
	public static String VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_NAME;

	public static String ID_MAPPING_UNRESOLVED_GENERATOR_NAME;
	public static String GENERATED_VALUE_UNRESOLVED_GENERATOR;
	public static String QUERY_DUPLICATE_NAME;
	public static String JPQL_QUERY_VALIDATION;

	private static final String BUNDLE_NAME = "jpt_ui_validation_preferences"; //$NON-NLS-1$
	private static final Class<?> BUNDLE_CLASS = JptUiValidationPreferenceMessages.class;

	private JptUiValidationPreferenceMessages() {
		throw new UnsupportedOperationException();
	}
}

}

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/details/NamedQueryPropertyComposite.java (-28 / +35 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 Oracle. All rights reserved.	2	* Copyright (c) 2008, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
Lines 15-24 Link Here
15	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;	15	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
16	import org.eclipse.jpt.jpa.core.context.NamedQuery;	16	import org.eclipse.jpt.jpa.core.context.NamedQuery;
17	import org.eclipse.jpt.jpa.core.context.Query;	17	import org.eclipse.jpt.jpa.core.context.Query;
		18	import org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlContentProposalProvider;
		19	import org.eclipse.swt.custom.StyledText;
18	import org.eclipse.swt.widgets.Composite;	20	import org.eclipse.swt.widgets.Composite;
19		21
20	/**	22	/**
21	* Here the layout of this pane:	23	* Here's the layout of this pane:
22	* <pre>	24	* <pre>
23	* -----------------------------------------------------------------------------	25	* -----------------------------------------------------------------------------
24	* \| ------------------------------------------------------------------ \|	26	* \| ------------------------------------------------------------------ \|
Lines 40-50 Link Here
40	* @see NamedQueriesComposite - The parent container	42	* @see NamedQueriesComposite - The parent container
41	* @see QueryHintsComposite	43	* @see QueryHintsComposite
42	*	44	*
43	* @version 2.0	45	* @version 2.3
44	* @since 2.0	46	* @since 2.3
45	*/	47	*/
46	public class NamedQueryPropertyComposite<T extends NamedQuery> extends Pane<T>	48	public class NamedQueryPropertyComposite<T extends NamedQuery> extends Pane<T> {
47	{	49
48	/**	50	/**
49	* Creates a new <code>NamedQueryPropertyComposite</code>.	51	* Creates a new <code>NamedQueryPropertyComposite</code>.
50	*	52	*
Lines 59-64 Link Here
59	super(parentPane, subjectHolder, parent);	61	super(parentPane, subjectHolder, parent);
60	}	62	}
61		63
		64	protected WritablePropertyValueModel<String> buildNameTextHolder() {
		65	return new PropertyAspectAdapter<NamedQuery, String>(
		66	getSubjectHolder(), Query.NAME_PROPERTY) {
		67	@Override
		68	protected String buildValue_() {
		69	return this.subject.getName();
		70	}
		71
		72	@Override
		73	protected void setValue_(String value) {
		74	if (value.length() == 0) {
		75	value = null;
		76	}
		77	this.subject.setName(value);
		78	}
		79	};
		80	}
		81
62	protected WritablePropertyValueModel<String> buildQueryHolder() {	82	protected WritablePropertyValueModel<String> buildQueryHolder() {
63	return new PropertyAspectAdapter<NamedQuery, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {	83	return new PropertyAspectAdapter<NamedQuery, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {
64	@Override	84	@Override
Lines 73-88 Link Here
73	};	93	};
74	}	94	}
75		95
		96	/**
		97	* {@inheritDoc}
		98	*/
76	@Override	99	@Override
77	protected void initializeLayout(Composite container) {	100	protected void initializeLayout(Composite container) {
78		101
79	addLabeledText(	102	addLabeledText(
80	container,	103	container,
81	JptUiDetailsMessages.NamedQueryComposite_nameTextLabel,	104	JptUiDetailsMessages.NamedQueryComposite_nameTextLabel,
82	buildNameTextHolder());	105	buildNameTextHolder());
83		106
84	// Query text area	107	// Query text area
85	addLabeledMultiLineText(	108	StyledText text = addLabeledMultiLineStyledText(
86	container,	109	container,
87	JptUiDetailsMessages.NamedQueryPropertyComposite_query,	110	JptUiDetailsMessages.NamedQueryPropertyComposite_query,
88	buildQueryHolder(),	111	buildQueryHolder(),
Lines 90-95 Link Here
90	null	113	null
91	);	114	);
92		115
		116	new JpaJpqlContentProposalProvider(getSubjectHolder(), text);
		117
93	// Query Hints pane	118	// Query Hints pane
94	container = addTitledGroup(	119	container = addTitledGroup(
95	addSubPane(container, 5),	120	addSubPane(container, 5),
Lines 98-119 Link Here
98		123
99	new QueryHintsComposite(this, container);	124	new QueryHintsComposite(this, container);
100	}	125	}
101
102	protected WritablePropertyValueModel<String> buildNameTextHolder() {
103	return new PropertyAspectAdapter<NamedQuery, String>(
104	getSubjectHolder(), Query.NAME_PROPERTY) {
105	@Override
106	protected String buildValue_() {
107	return this.subject.getName();
108	}
109
110	@Override
111	protected void setValue_(String value) {
112	if (value.length() == 0) {
113	value = null;
114	}
115	this.subject.setName(value);
116	}
117	};
118	}
119	}	126	}




import org.eclipse.jface.window.Window;
import org.eclipse.jpt.common.ui.internal.util.ControlSwitcher;
import org.eclipse.jpt.common.ui.internal.widgets.AddRemoveListPane;
import org.eclipse.jpt.common.ui.internal.widgets.Pane;
import org.eclipse.jpt.common.ui.internal.widgets.AddRemovePane.Adapter;
import org.eclipse.jpt.common.ui.internal.widgets.Pane;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.Transformer;
import org.eclipse.jpt.common.utility.internal.model.value.CompositeListValueModel;

{
	private AddRemoveListPane<QueryContainer> listPane;
	NamedNativeQueryPropertyComposite namedNativeQueryPane;
	Pane<? extends NamedQuery> namedQueryPane;
	private WritablePropertyValueModel<Query> queryHolder;



		installPaneSwitcher(pageBook);
	}
	
	protected Pane<? extends NamedQuery> buildNamedQueryPropertyComposite(PageBook pageBook) {
		return new NamedQueryPropertyComposite<NamedQuery>(
			this,
			this.buildNamedQueryHolder(),

Lines 1-27 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/jpa2/details/NamedQueryProperty2_0Composite.java (-15 / +82 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009 Oracle. All rights reserved.	2	* Copyright (c) 2009, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	*******************************************************************************/	9	*******************************************************************************/
10	package org.eclipse.jpt.jpa.ui.internal.jpa2.details;	10	package org.eclipse.jpt.jpa.ui.internal.jpa2.details;
11		11
12	import org.eclipse.jpt.common.ui.internal.widgets.Pane;	12	import org.eclipse.jpt.common.ui.internal.widgets.Pane;
		13	import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;
13	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;	14	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
		15	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
		16	import org.eclipse.jpt.jpa.core.context.Query;
14	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;	17	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;
15	import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;	18	import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;
16	import org.eclipse.jpt.jpa.ui.internal.details.NamedQueryPropertyComposite;
17	import org.eclipse.jpt.jpa.ui.internal.details.QueryHintsComposite;	19	import org.eclipse.jpt.jpa.ui.internal.details.QueryHintsComposite;
		20	import org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlContentProposalProvider;
		21	import org.eclipse.swt.custom.StyledText;
18	import org.eclipse.swt.widgets.Composite;	22	import org.eclipse.swt.widgets.Composite;
19		23
20	/**	24	/**
21	* NamedQueryProperty2_0Composite	25	* Here's the layout of this pane:
		26	* <pre>
		27	* -----------------------------------------------------------------------------
		28	* \| -------------------------------------------------------------- \|
		29	* \| Query: \| I \| \|
		30	* \| \| \| \|
		31	* \| \| \| \|
		32	* \| -------------------------------------------------------------- \|
		33	* \| -------------------------------------------------------------- \|
		34	* \| Lock Mode: \| \|v\| \|
		35	* \| -------------------------------------------------------------- \|
		36	* \| \|
		37	* \| - Query Hints ----------------------------------------------------------- \|
		38	* \| \| --------------------------------------------------------------------- \| \|
		39	* \| \| \| \| \| \|
		40	* \| \| \| QueryHintsComposite \| \| \|
		41	* \| \| \| \| \| \|
		42	* \| \| --------------------------------------------------------------------- \| \|
		43	* \| ------------------------------------------------------------------------- \|
		44	* -----------------------------------------------------------------------------</pre>
		45	*
		46	*
		47	* @see NamedQuery2_0
		48	* @see NamedQueriesComposite - The parent container
		49	* @see QueryHintsComposite
		50	*
		51	* @version 2.0
		52	* @since 2.0
22	*/	53	*/
23	public class NamedQueryProperty2_0Composite extends NamedQueryPropertyComposite<NamedQuery2_0>	54	public class NamedQueryProperty2_0Composite extends Pane<NamedQuery2_0> {
24	{	55
25	/**	56	/**
26	* Creates a new <code>NamedQueryProperty2_0Composite</code>.	57	* Creates a new <code>NamedQueryProperty2_0Composite</code>.
27	*	58	*
Lines 30-51 Link Here
30	* @param parent The parent container	61	* @param parent The parent container
31	*/	62	*/
32	public NamedQueryProperty2_0Composite(Pane<?> parentPane,	63	public NamedQueryProperty2_0Composite(Pane<?> parentPane,
33	PropertyValueModel<NamedQuery2_0> subjectHolder,	64	PropertyValueModel<NamedQuery2_0> subjectHolder,
34	Composite parent) {	65	Composite parent) {
35		66
36	super(parentPane, subjectHolder, parent);	67	super(parentPane, subjectHolder, parent);
37	}	68	}
38		69
		70	protected WritablePropertyValueModel<String> buildNameTextHolder() {
		71	return new PropertyAspectAdapter<NamedQuery2_0, String>(getSubjectHolder(), Query.NAME_PROPERTY) {
		72	@Override
		73	protected String buildValue_() {
		74	return this.subject.getName();
		75	}
		76
		77	@Override
		78	protected void setValue_(String value) {
		79	if (value.length() == 0) {
		80	value = null;
		81	}
		82	this.subject.setName(value);
		83	}
		84	};
		85	}
		86
		87	protected WritablePropertyValueModel<String> buildQueryHolder() {
		88	return new PropertyAspectAdapter<NamedQuery2_0, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {
		89	@Override
		90	protected String buildValue_() {
		91	return this.subject.getQuery();
		92	}
		93
		94	@Override
		95	protected void setValue_(String value) {
		96	this.subject.setQuery(value);
		97	}
		98	};
		99	}
		100
		101	/**
		102	* {@inheritDoc}
		103	*/
39	@Override	104	@Override
40	protected void initializeLayout(Composite container) {	105	protected void initializeLayout(Composite container) {
41		106
42	this.addLabeledText(	107	this.addLabeledText(
43	container,	108	container,
44	JptUiDetailsMessages.NamedQueryComposite_nameTextLabel,	109	JptUiDetailsMessages.NamedQueryComposite_nameTextLabel,
45	this.buildNameTextHolder());	110	this.buildNameTextHolder());
46		111
47	// Query text area	112	// Query text area
48	this.addLabeledMultiLineText(	113	StyledText text = this.addLabeledMultiLineStyledText(
49	container,	114	container,
50	JptUiDetailsMessages.NamedQueryPropertyComposite_query,	115	JptUiDetailsMessages.NamedQueryPropertyComposite_query,
51	this.buildQueryHolder(),	116	this.buildQueryHolder(),
Lines 53-60 Link Here
53	null	118	null
54	);	119	);
55		120
		121	new JpaJpqlContentProposalProvider(getSubjectHolder(), text);
		122
		123	// Lock Mode type
56	new LockModeComposite(this, container);	124	new LockModeComposite(this, container);
57		125
58	// Query Hints pane	126	// Query Hints pane
59	container = this.addTitledGroup(	127	container = this.addTitledGroup(
60	this.addSubPane(container, 5),	128	this.addSubPane(container, 5),
Lines 63-67 Link Here
63		131
64	new QueryHintsComposite(this, container);	132	new QueryHintsComposite(this, container);
65	}	133	}
66		134	}
67	}




import org.eclipse.jpt.jpa.core.context.Query;
import org.eclipse.jpt.jpa.core.context.QueryContainer;
import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;
import org.eclipse.jpt.jpa.ui.internal.details.NamedQueryPropertyComposite;
import org.eclipse.jpt.jpa.ui.internal.details.QueriesComposite;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.PageBook;

		super(parentPane, subjectHolder, parent);
	}
	
	
	@Override
	protected Pane<NamedQuery2_0> buildNamedQueryPropertyComposite(PageBook pageBook) {
		return new NamedQueryProperty2_0Composite(
			this,
			this.buildNamedQuery2_0Holder(),

			}
		};
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.expressions.EvaluationResult;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.expressions.ExpressionInfo;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.jface.bindings.Binding;
import org.eclipse.jface.bindings.Trigger;
import org.eclipse.jface.bindings.keys.KeyStroke;
import org.eclipse.jface.bindings.keys.SWTKeySupport;
import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.jface.fieldassist.FieldDecorationRegistry;
import org.eclipse.jface.text.DefaultTextHover;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.contentassist.ContentAssistant;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.AnnotationModel;
import org.eclipse.jface.text.source.DefaultAnnotationHover;
import org.eclipse.jface.text.source.IAnnotationHover;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.source.SourceViewerConfiguration;
import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent;
import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
import org.eclipse.jpt.jpa.ui.internal.JptUiMessages;
import org.eclipse.osgi.util.NLS;
import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISources;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.internal.editors.text.EditorsPlugin;
import org.eclipse.ui.keys.IBindingService;
import org.eclipse.ui.swt.IFocusService;
import org.eclipse.ui.texteditor.AnnotationPreference;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;

/**
 * This provider installs content assist support on a {@link StyledText} widget in order to give
 * choices at any given position within a JPQL query.
 * <p>
 * NOTE 1: Add a timer before validating.
 * <p>
 * NOTE 2. I think it's possible to install error highlight into the SourceViewer rather than doing
 *         it manually.
 * <p>
 * NOTE 3. Add syntax highlight for the JPQL identifiers.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings({"nls", "restriction"})
public final class JpaJpqlContentProposalProvider extends JpqlCompletionProposalComputer<ICompletionProposal> {

	/**
	 * This model holds onto the {@link Annotation annotations} that have been created for each
	 * {@link JPQLQueryProblem}
	 */
	private AnnotationModel annotationModel;

	/**
	 * The {@link Color} of the highlight.
	 */
	private Color errorColor;

	/**
	 * This handler will trigger an event that will be used to notify the {@link SourceViewer} to
	 * invoke the content assist.
	 */
	private IHandlerActivation handlerActivation;

	/**
	 * The position within the JPQL query.
	 */
	private int position;

	/**
	 * The holder of the named query.
	 */
	private PropertyValueModel<? extends NamedQuery> queryHolder;

	/**
	 * This manager is responsible to only keep the union of the ranges that were created by
	 * validating the JPQL query.
	 */
	private RangeManager rangeManager;

	/**
	 * The {@link ResourceBundle} that contains the JPQL problems.
	 */
	private ResourceBundle resourceBundle;

	/**
	 * This viewer is used to install various functionality over the {@link StyledText}.
	 */
	private SourceViewer sourceViewer;

	/**
	 * The widget used to display the JPQL query.
	 */
	private StyledText styledText;

	/**
	 * The unique identifier - appended by hashCode() - used to register the widget with the focus
	 * handler.
	 */
	private static final String CONTROL_ID = "jpql.focus.control";

	/**
	 * The unique identifier used to mark an {@link Annotation} as a JPQL problem.
	 */
	private static final String ERROR_TYPE = "jpql.error";

	/**
	 * Creates a new <code>JpaJpqlContentProposalProvider</code>.
	 *
	 * @param queryHolder The holder of the named query
	 * @param styledText The {@link StyledText} widget that shows the JPQL query
	 */
	public JpaJpqlContentProposalProvider(PropertyValueModel<? extends NamedQuery> queryHolder,
	                                      StyledText styledText) {

		super();
		initialize(queryHolder, styledText);
	}

	private void activateHandler() {

		IWorkbench workbench = PlatformUI.getWorkbench();
		IFocusService focusService = (IFocusService) workbench.getService(IFocusService.class);
		IHandlerService handlerService = (IHandlerService) workbench.getService(IHandlerService.class);

		if ((focusService != null) && (handlerService != null)) {

			focusService.addFocusTracker(styledText, CONTROL_ID + hashCode());

			Expression expression = buildExpression();
			IHandler handler = buildHandler();

			handlerActivation = handlerService.activateHandler(
				ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS,
				handler,
				expression
			);

			handlerActivation = handlerService.activateHandler(
				ActionFactory.UNDO.getCommandId(),
				handler,
				expression
			);

			handlerActivation = handlerService.activateHandler(
				ActionFactory.REDO.getCommandId(),
				handler,
				expression
			);
		}
	}

	private DisposeListener buildDisposeListener() {
		return new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				dispose();
			}
		};
	}

	private Expression buildExpression() {
		return new Expression() {
			@Override
			public void collectExpressionInfo(ExpressionInfo info) {
				info.addVariableNameAccess(ISources.ACTIVE_FOCUS_CONTROL_NAME);
			}
			@Override
			public EvaluationResult evaluate(IEvaluationContext context) {
				Object variable = context.getVariable(ISources.ACTIVE_FOCUS_CONTROL_NAME);
				return (variable == styledText) ? EvaluationResult.TRUE : EvaluationResult.FALSE;
			}
		};
	}

	private IHandler buildHandler() {
		return new AbstractHandler() {
			public Object execute(ExecutionEvent event) throws ExecutionException {
				String commandId = event.getCommand().getId();

				// Content Assist
				if (ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS.equals(commandId)) {
					sourceViewer.doOperation(ISourceViewer.CONTENTASSIST_PROPOSALS);
				}
				// Undo
				else if (ActionFactory.UNDO.getCommandId().equals(commandId)) {
					if (sourceViewer.getUndoManager().undoable()) {
						sourceViewer.getUndoManager().undo();
					}
				}
				// Redo
				else if (ActionFactory.REDO.getCommandId().equals(commandId)) {
					if (sourceViewer.getUndoManager().redoable()) {
						sourceViewer.getUndoManager().redo();
					}
				}

				return null;
			}
		};
	}

	private String buildMessage(JPQLQueryProblem problem) {
		String message = resourceBundle().getString(problem.getMessageKey());
		message = MessageFormat.format(message, (Object[]) problem.getMessageArguments());
		return message;
	}

	private ModifyListener buildModifyListener() {
		return new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validate();
			}
		};
	}

	private Comparator<JPQLQueryProblem> buildProblemComparator() {
		return new Comparator<JPQLQueryProblem>() {
			public int compare(JPQLQueryProblem problem1, JPQLQueryProblem problem2) {
				int result = problem1.getStartPosition() - problem2.getStartPosition();
				if (result == 0) {
					result = problem1.getEndPosition() - problem2.getEndPosition();
				}
				return result;
			}
		};
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	ICompletionProposal buildProposal(String proposal,
	                                  String displayString,
	                                  String additionalInfo,
	                                  Image image,
	                                  int cursorOffset) {

		return new JpqlCompletionProposal(
			contentAssistProposals,
			proposal,
			displayString,
			additionalInfo,
			image,
			namedQuery,
			actualQuery,
			jpqlQuery,
			offset,
			position,
			cursorOffset,
			false
		);
	}

	private SourceViewer buildSourceViewer() {
		return new SourceViewer(styledText.getParent(), null, styledText.getStyle()) {
			@Override
			protected StyledText createTextWidget(Composite parent, int styles) {
				return styledText;
			}
		};
	}

	private PropertyChangeListener buildSubjectChangeListener() {
		return new PropertyChangeListener() {
			public void propertyChanged(PropertyChangeEvent e) {
				if (e.getNewValue() != null) {
					sourceViewer.getUndoManager().reset();
				}
			}
		};
	}

	private Image contentAssistImage() {
		FieldDecorationRegistry registry = FieldDecorationRegistry.getDefault();
		return registry.getFieldDecoration(FieldDecorationRegistry.DEC_CONTENT_PROPOSAL).getImage();
	}

	/**
	 * Makes sure the {@link Color} used to paint the underlying problem is disposed when the
	 * {@link StyledText} widget is disposed.
	 */
	private void dispose() {

		if (errorColor != null) {
			errorColor.dispose();
			errorColor = null;
		}

		IWorkbench workbench = PlatformUI.getWorkbench();
		IHandlerService handlerService = (IHandlerService) workbench.getService(IHandlerService.class);
		handlerService.deactivateHandler(handlerActivation);
	}

	private Color errorColor() {
		// TODO: Support the color changing
		if (errorColor == null) {
			// TODO: Is there a better way to do this?
			for (Object object : EditorsPlugin.getDefault().getMarkerAnnotationPreferences().getAnnotationPreferences()) {
				AnnotationPreference preference = (AnnotationPreference) object;
				if ("org.eclipse.ui.workbench.texteditor.error".equals(preference.getAnnotationType())) {
					errorColor = new Color(styledText.getDisplay(), preference.getColorPreferenceValue());
					break;
				}
			}
			if (errorColor == null) {
				errorColor = new Color(styledText.getDisplay(), 255, 0, 0);
			}
		}
		return errorColor;
	}

	private KeyStroke findContentAssistTrigger() {

		IBindingService bindingService = (IBindingService) PlatformUI.getWorkbench().getService(IBindingService.class);

		// Dig through the list of available bindings to find the one for content assist
		for (Binding binding : bindingService.getBindings()) {
			if (isContentAssistBinding(binding)) {
				Trigger[] triggers = binding.getTriggerSequence().getTriggers();
				if ((triggers != null) && (triggers.length > 0)) {
					return (KeyStroke) triggers[0];
				}
			}
		}

		// The default trigger was not found, use the default
		return KeyStroke.getInstance(SWT.CTRL, ' ');
	}

	private void initialize(PropertyValueModel<? extends NamedQuery> queryHolder,
	                        StyledText styledText) {

		this.styledText      = styledText;
		this.queryHolder     = queryHolder;
		this.rangeManager    = new RangeManager();
		this.annotationModel = new AnnotationModel();
		this.styledText.addModifyListener (buildModifyListener());
		this.styledText.addDisposeListener(buildDisposeListener());

		// Make sure the user can't delete the entire query when doing undo
		queryHolder.addPropertyChangeListener(PropertyValueModel.VALUE, buildSubjectChangeListener());

		// Add the content assist image at the top left corner
		installControlDecoration();

		// Create the SourceViewer, which is responsible for everything: content assist, tool tip
		// hovering over the annotation (problems), etc
		sourceViewer = buildSourceViewer();
		sourceViewer.configure(new JpqlSourceViewerConfiguration());
		sourceViewer.setDocument(new Document(), annotationModel);

		// Bind the content assist key trigger with the handler service
		activateHandler();

		// Install a custom context menu to the widget
		TextTransferHandler.installContextMenu(styledText, sourceViewer.getUndoManager());
	}

	private void installControlDecoration() {

		// Retrieve the content assist trigger
		KeyStroke contentAssistTrigger = findContentAssistTrigger();
		String key = SWTKeySupport.getKeyFormatterForPlatform().format(contentAssistTrigger);

		// Add the context assist icon at the top left corner of the StyledText
		ControlDecoration decoration = new ControlDecoration(styledText, SWT.LEFT | SWT.TOP);
		decoration.setDescriptionText(NLS.bind(JptUiMessages.JpqlContentProposalProvider_Description, key));
		decoration.setImage(contentAssistImage());
		decoration.setShowOnlyOnFocus(true);
	}

	private boolean isContentAssistBinding(Binding binding) {

		ParameterizedCommand command = binding.getParameterizedCommand();

		return command != null &&
		       command.getCommand() != null &&
		       command.getCommand().getId().equals(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
	}

	private NamedQuery query() {
		return queryHolder.getValue();
	}

	private ResourceBundle resourceBundle() {
		if (resourceBundle == null) {
			resourceBundle = ResourceBundle.getBundle(
				"jpa_jpql_validation",
				Locale.getDefault(),
				JptJpaCorePlugin.class.getClassLoader()
			);
		}
		return resourceBundle;
	}

	private List<JPQLQueryProblem> sortProblems(List<JPQLQueryProblem> problems) {
		Collections.sort(problems, buildProblemComparator());
		return problems;
	}

	/**
	 * Validates the given JPQL query and add highlights where problems have been found.
	 */
	private void validate() {

		NamedQuery query = query();

		if ((query != null) && !styledText.isDisposed()) {

			String jpqlQuery = styledText.getText();
			rangeManager.clear();

			JpaJpqlQueryHelper helper = new JpaJpqlQueryHelper(query, jpqlQuery);
			String parsedJpqlQuery = helper.getParsedJPQLQuery();

			for (JPQLQueryProblem problem : sortProblems(helper.validate())) {

				// Create the range
				int[] positions = helper.buildPositions(problem, parsedJpqlQuery, jpqlQuery);
				rangeManager.addRange(positions);

				// Add the problem to the tool tip
				Annotation annotation = new Annotation(ERROR_TYPE, true, buildMessage(problem));
				annotationModel.addAnnotation(annotation, new Position(positions[0], positions[1] - positions[0]));
			}

			// Update the widget
			styledText.setStyleRanges(rangeManager.buildStyleRanges());
		}
	}

	/**
	 * This processor is responsible to create the list of {@link ICompletionProposal proposals}
	 * based on the position of the cursor within the query.
	 */
	private class ContentAssistProcessor implements IContentAssistProcessor {

		/**
		 * {@inheritDoc}
		 */
		public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {

			JpaJpqlContentProposalProvider.this.position = offset;

			String jpqlQuery = viewer.getDocument().get();
			List<ICompletionProposal> proposals = buildProposals(query(), jpqlQuery, 0, position);
			return proposals.toArray(new ICompletionProposal[proposals.size()]);
		}

		/**
		 * {@inheritDoc}
		 */
		public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
			return null;
		}

		/**
		 * {@inheritDoc}
		 */
		public char[] getCompletionProposalAutoActivationCharacters() {
			return null;
		}

		/**
		 * {@inheritDoc}
		 */
		public char[] getContextInformationAutoActivationCharacters() {
			return null;
		}

		/**
		 * {@inheritDoc}
		 */
		public IContextInformationValidator getContextInformationValidator() {
			return null;
		}

		/**
		 * {@inheritDoc}
		 */
		public String getErrorMessage() {
			return null;
		}
	}

	private class JpqlSourceViewerConfiguration extends SourceViewerConfiguration {

		/**
		 * {@inheritDoc}
		 */
		@Override
		public IAnnotationHover getAnnotationHover(ISourceViewer sourceViewer) {
			return new DefaultAnnotationHover();
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public IContentAssistant getContentAssistant(ISourceViewer sourceViewer) {
			ContentAssistant assistant = new ContentAssistant();
			assistant.setContentAssistProcessor(new ContentAssistProcessor(), IDocument.DEFAULT_CONTENT_TYPE);
			return assistant;
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType) {
			return new DefaultTextHover(sourceViewer);
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType, int stateMask) {
			return new DefaultTextHover(sourceViewer);
		}
	}

	/**
	 * This manager is responsible to only keep the union of the ranges that were created by
	 * validating the JPQL query.
	 */
	private class RangeManager {

		/**
		 * The {@link StyleRange ranges} that will will be used to paint the highlight under the JPQL
		 * query where the query is grammatically and/or semantically invalid
		 */
		List<int[]> ranges;

		/**
		 * Creates a new <code>RangeManager</code>.
		 */
		RangeManager() {
			super();
			ranges = new ArrayList<int[]>();
		}

		/**
		 * Adds the given range (start and end positions) to this manager and if an existing range is
		 * within the given one, then they will be merged to make the union of the two ranges.
		 *
		 * @param range The start and end position of the problem
		 */
		void addRange(int[] range) {
			ranges.add(range);
			if (ranges.size() > 1) {
				mergeRanges();
			}
		}

		private Comparator<StyleRange> buildComparator() {
			return new Comparator<StyleRange>() {
				public int compare(StyleRange range1, StyleRange range2) {
					return range1.start - range2.start;
				}
			};
		}

		/**
		 * Creates the list of {@link StyleRange ranges} that will will be used to paint the highlight
		 * under the JPQL query where the query is grammatically and/or semantically invalid.
		 *
		 * @return The list of {@link StyleRange ranges}
		 */
		StyleRange[] buildStyleRanges() {

			StyleRange[] styleRanges = new StyleRange[ranges.size()];

			for (int index = ranges.size(); --index >= 0; ) {
				int[] positions = ranges.get(index);

				StyleRange styleRange = new StyleRange();
				styleRange.start          = positions[0];
				styleRange.length         = positions[1] - positions[0];
				styleRange.underline      = true;
				styleRange.underlineColor = errorColor();
				styleRange.underlineStyle = SWT.UNDERLINE_ERROR;
				styleRanges[index]        = styleRange;
			}

			Arrays.sort(styleRanges, buildComparator());
			return styleRanges;
		}

		/**
		 * Clears the registered ranges.
		 */
		void clear() {
			ranges.clear();
		}

		private void mergeRanges() {

			for (int firstIndex = 0, count = ranges.size(); firstIndex < count; firstIndex++) {
				int[] firstRange = ranges.get(firstIndex);

				for (int secondIndex = firstIndex + 1; secondIndex < count; secondIndex++) {
					int[] secondRange = ranges.get(secondIndex);
					boolean merged = false;

					// range  └───┘
					// to add   └──────┘
					// become └────────┘
					if (firstRange[0] <= secondRange[0] &&
					    firstRange[1] >= secondRange[0]) {

						firstRange[1] = Math.max(firstRange[1], secondRange[1]);
						merged = true;
					}
					// range       └───┘
					// to add └──────┘
					// become └────────┘
					else if (firstRange[1] >= secondRange[1] &&
					         firstRange[0] <= secondRange[1]) {

						firstRange[0] = Math.min(firstRange[0], secondRange[0]);
						merged = true;
					}

					if (merged) {
						merged = false;
						ranges.remove(secondIndex);
						secondIndex--;
						count--;
					}
				}
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.CompletionContext;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IExtendedModifier;
import org.eclipse.jdt.core.dom.MemberValuePair;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.ui.text.java.ContentAssistInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposalComputer;
import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jpt.common.core.internal.utility.jdt.ASTTools;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.jpa.core.JpaFile;
import org.eclipse.jpt.jpa.core.JpaStructureNode;
import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpa.core.context.java.JavaTypeMapping;
import org.eclipse.jpt.jpa.ui.JptJpaUiPlugin;
import org.eclipse.jpt.jpa.ui.internal.JptUiMessages;
import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.swt.graphics.Image;

/**
 * This computer adds content assist support when it is invoked inside the query element of {@link
 * javax.persistence.NamedQuery &#64;NamedQuery}.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("restriction")
public final class JpaJpqlJavaCompletionProposalComputer extends JpqlCompletionProposalComputer<ICompletionProposal>
                                                         implements IJavaCompletionProposalComputer {

	/**
	 * Creates a new <code>JpaJpqlJavaCompletionProposalComputer</code>.
	 */
	public JpaJpqlJavaCompletionProposalComputer() {
		super();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	ICompletionProposal buildProposal(String proposal,
	                                  String displayString,
	                                  String additionalInfo,
	                                  Image image,
	                                  int cursorOffset) {

		return new JpqlCompletionProposal(
			contentAssistProposals,
			proposal,
			displayString,
			additionalInfo,
			image,
			namedQuery,
			actualQuery,
			jpqlQuery,
			offset + 1, // +1 is to skip the opening "
			position,
			cursorOffset,
			true
		);
	}

	/**
	 * {@inheritDoc}
	 */
	public List<ICompletionProposal> computeCompletionProposals(ContentAssistInvocationContext context,
	                                                            IProgressMonitor monitor) {

		if (context instanceof JavaContentAssistInvocationContext) {
			monitor.beginTask(null, 100);
			try {
				return computeCompletionProposals((JavaContentAssistInvocationContext) context, monitor);
			}
			catch (Exception e) {
				Status status = new Status(IStatus.ERROR, JptJpaUiPlugin.PLUGIN_ID, JptUiMessages.JpaJpqlJavaCompletionProposalComputer_Error, e);
				JptJpaCorePlugin.log(status);
			}
			finally {
				monitor.done();
			}
		}

		return Collections.emptyList();
	}

	private List<ICompletionProposal> computeCompletionProposals(JavaContentAssistInvocationContext context,
	                                                             IProgressMonitor monitor) throws Exception {

		CompletionContext completionContext = context.getCoreContext();

		// The token "start" is the offset of the token's first character within the document.
		// A token start of -1 can means:
		// - It is inside the string representation of a unicode character, \\u0|0E9 where | is the
		//   cursor, then -1 is returned;
		// - The string is not valid (it has some invalid characters)
		int tokenStart = completionContext.getTokenStart();
		if (tokenStart == -1) return Collections.emptyList();

		int[] position = { completionContext.getOffset() - tokenStart - 1 };
		if (position[0] < 0) return Collections.emptyList();

		ICompilationUnit compilationUnit = context.getCompilationUnit();
		if (compilationUnit == null) return Collections.emptyList();
		CompilationUnit astRoot = ASTTools.buildASTRoot(compilationUnit);

		IFile file = getCorrespondingResource(compilationUnit);
		if (file == null) return Collections.emptyList();

		JpaFile jpaFile = JptJpaCorePlugin.getJpaFile(file);
		if (jpaFile == null) return Collections.emptyList();

		monitor.worked(80);
		checkCanceled(monitor);

		// Retrieve the JPA's model object
		NamedQuery namedQuery = namedQuery(astRoot, jpaFile, tokenStart);
		if (namedQuery == null) return Collections.emptyList();

		// Retrieve the actual value of the element "query" since the content assist can be
		// invoked before the model received the new content
		String jpqlQuery = jpqlQuery(astRoot, tokenStart, completionContext.getTokenEnd(), position);

		// Now create the proposals
		return buildProposals(namedQuery, jpqlQuery, tokenStart, position[0]);
	}

	/**
	 * {@inheritDoc}
	 */
	public List<IContextInformation> computeContextInformation(ContentAssistInvocationContext context,
	                                                           IProgressMonitor monitor) {

		return Collections.emptyList();
	}

	private NamedQuery findNamedQuery(JpaStructureNode structureNode,
	                                  CompilationUnit astRoot,
	                                  int tokenStart) {

		if (structureNode instanceof JavaPersistentType) {
			JavaPersistentType persistentType = (JavaPersistentType) structureNode;
			JavaTypeMapping typeMapping = persistentType.getMapping();

			if (typeMapping instanceof JavaEntity) {
				JavaEntity entity = (JavaEntity) typeMapping;

				for (Iterator<JavaNamedQuery> queries = entity.getQueryContainer().namedQueries(); queries.hasNext(); ) {
					JavaNamedQuery namedQuery = queries.next();
					TextRange textRange = namedQuery.getQueryAnnotation().getQueryTextRange(astRoot);

					if ((textRange != null) && textRange.includes(tokenStart)) {
						return namedQuery;
					}
				}
			}
		}

		return null;
	}

	private IFile getCorrespondingResource(ICompilationUnit compilationUnit) {
		try {
			return (IFile) compilationUnit.getCorrespondingResource();
		}
		catch (JavaModelException ex) {
			JptJpaCorePlugin.log(ex);
			return null;
		}
	}

	private boolean isInsideNode(ASTNode node, int tokenStart, int tokenEnd) {
		int startPosition = node.getStartPosition();
		return startPosition <= tokenStart &&
		       startPosition + node.getLength() >= tokenEnd;
	}

	private String jpqlQuery(CompilationUnit astRoot, int tokenStart, int tokenEnd, int[] position) {

		String jpqlQuery = retrieveQuery(astRoot, tokenStart, tokenEnd);

		if (jpqlQuery == null) {
			jpqlQuery = StringTools.EMPTY_STRING;
		}
		else if (StringTools.stringIsQuoted(jpqlQuery)) {
			jpqlQuery = jpqlQuery.substring(1, jpqlQuery.length() - 1);
		}

		return jpqlQuery;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	String modifyJpqlQuery(String jpqlQuery, int[] position) {
		return ExpressionTools.unescape(jpqlQuery, position);
	}

	private NamedQuery namedQuery(CompilationUnit astRoot, JpaFile jpaFile, int tokenStart) {

		for (JpaStructureNode node : jpaFile.getRootStructureNodes()) {
			NamedQuery namedQuery = findNamedQuery(node, astRoot, tokenStart);
			if (namedQuery != null) {
				return namedQuery;
			}
		}

		return null;
	}

	/**
	 * This twisted code is meant to retrieve the real string value that is not escaped and to also
	 * retrieve the position within the non-escaped string. The query could have escape characters,
	 * such as \r, \n etc being written as \\r, \\n, the position is based on that escaped string,
	 * the conversion will convert them into \r and \r and adjust the position accordingly.
	 *
	 * @param astRoot The parsed tree representation of the Java source file
	 * @param tokenStart The beginning of the query expression of the {@link javax.persistence.NamedQuery
	 * &#64;NamedQuery}'s query member within the source file
	 * @param tokenEnd The end of the query member within the source file
	 * @param position The position of the cursor within the query expression
	 * @return The actual value retrieved from the query element
	 */
	@SuppressWarnings("unchecked")
	private String retrieveQuery(CompilationUnit astRoot, int tokenStart, int tokenEnd) {

		// Dig into the TypeDeclarations
		for (AbstractTypeDeclaration type : (List<AbstractTypeDeclaration>) astRoot.types()) {

			if (isInsideNode(type, tokenStart, tokenEnd)) {

				// Dig inside its modifiers and annotations
				for (IExtendedModifier modifier : (List<IExtendedModifier>) type.modifiers()) {

					if (!modifier.isAnnotation()) {
						continue;
					}

					Annotation annotation = (Annotation) modifier;

					// Dig inside the annotation
					if (isInsideNode(annotation, tokenStart, tokenEnd)) {

						// @NamedQueries({...})
						if (annotation.isSingleMemberAnnotation()) {
							SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) annotation;
							ArrayInitializer array = (ArrayInitializer) singleMemberAnnotation.getValue();

							for (org.eclipse.jdt.core.dom.Expression expression : (List<org.eclipse.jdt.core.dom.Expression>) array.expressions()) {
								if (isInsideNode(expression, tokenStart, tokenEnd)) {
									return retrieveQuery((NormalAnnotation) expression, tokenStart, tokenEnd);
								}
							}
						}
						// @NamedQuery()
						else if (annotation.isNormalAnnotation()) {
							return retrieveQuery((NormalAnnotation) annotation, tokenStart, tokenEnd);
						}
					}
				}
			}
		}

		return null;
	}

	@SuppressWarnings("unchecked")
	private String retrieveQuery(NormalAnnotation annotation, int tokenStart, int tokenEnd) {

		for (MemberValuePair pair : (List<MemberValuePair>) annotation.values()) {
			org.eclipse.jdt.core.dom.Expression expression = pair.getValue();

			if (isInsideNode(expression, tokenStart, tokenEnd)) {
				StringLiteral literal = (StringLiteral) pair.getValue();
				return literal.getEscapedValue();
			}
		}

		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.jpa.core.JpaFile;
import org.eclipse.jpt.jpa.core.JpaStructureNode;
import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.QueryContainer;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.jpt.jpa.core.context.orm.EntityMappings;
import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
import org.eclipse.jpt.jpa.core.context.orm.OrmNamedQuery;
import org.eclipse.jpt.jpa.ui.JptJpaUiPlugin;
import org.eclipse.jpt.jpa.ui.internal.JptUiMessages;
import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.swt.graphics.Image;
import org.eclipse.wst.sse.ui.contentassist.CompletionProposalInvocationContext;
import org.eclipse.wst.sse.ui.contentassist.ICompletionProposalComputer;

/**
 * This computer adds content assist support when it is invoked inside the &lt;query&gt; element
 * defined in a mapping file (ORM Configuration).
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
public final class JpaJpqlSseCompletionProposalComputer extends JpqlCompletionProposalComputer<ICompletionProposal>
                                                        implements ICompletionProposalComputer {

	/**
	 * Creates a new <code>JpaJpqlSseCompletionProposalComputer</code>.
	 */
	public JpaJpqlSseCompletionProposalComputer() {
		super();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	ICompletionProposal buildProposal(String proposal,
	                                  String displayString,
	                                  String additionalInfo,
	                                  Image image,
	                                  int cursorOffset) {

		return new JpqlCompletionProposal(
			contentAssistProposals,
			proposal,
			displayString,
			additionalInfo,
			image,
			namedQuery,
			actualQuery,
			jpqlQuery,
			offset,
			position,
			cursorOffset,
			true
		);
	}

	/**
	 * {@inheritDoc}
	 */
	public List<ICompletionProposal> computeCompletionProposals(CompletionProposalInvocationContext context,
	                                                            IProgressMonitor monitor) {

		monitor.beginTask(null, 100);

		try {
			int offset = context.getInvocationOffset();
			if (offset == -1) return Collections.emptyList();

			ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
			ITextFileBuffer buffer = manager.getTextFileBuffer(context.getDocument());
			if (buffer == null) return Collections.emptyList();

			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
			IFile file = root.getFile(buffer.getLocation());

			JpaFile jpaFile = JptJpaCorePlugin.getJpaFile(file);
			if (jpaFile == null) return Collections.emptyList();

			monitor.worked(80);
			checkCanceled(monitor);

			// Retrieve the JPA's model object
			int[] position = new int[1];
			NamedQuery namedQuery = namedQuery(jpaFile, offset, position);
			if (namedQuery == null) return Collections.emptyList();

			// Keep track of the beginning of the text since the entire string is always replaced
			int tokenStart = offset - position[0];

			// Now create the proposals
			String jpqlQuery = jpqlQuery(namedQuery, position[0]);
			return buildProposals(namedQuery, jpqlQuery, tokenStart, position[0]);
		}
		catch (Exception e) {
			Status status = new Status(IStatus.ERROR, JptJpaUiPlugin.PLUGIN_ID, JptUiMessages.JpaJpqlSseCompletionProposalComputer_Error, e);
			JptJpaCorePlugin.log(status);
		}
		finally {
			monitor.done();
		}

		return Collections.emptyList();
	}

	/**
	 * {@inheritDoc}
	 */
	public List<IContextInformation> computeContextInformation(CompletionProposalInvocationContext context,
	                                                           IProgressMonitor monitor) {

		return Collections.emptyList();
	}

	private NamedQuery findNamedQuery(JpaStructureNode structureNode, int offset, int[] position) {

		if (structureNode instanceof EntityMappings) {
			EntityMappings entityMappings = (EntityMappings) structureNode;

			// First look into the global queries
			NamedQuery query = findNamedQuery(entityMappings.getQueryContainer(), offset, position);

			// Now traverse each entity
			if (query != null) {
				return query;
			}

			for (PersistentType persistentType : entityMappings.getPersistentTypes()) {
				TypeMapping typeMapping = persistentType.getMapping();

				if (typeMapping instanceof OrmEntity) {
					query = findNamedQuery(((OrmEntity) typeMapping).getQueryContainer(), offset, position);

					if (query != null) {
						return query;
					}
				}
			}
		}

		return null;
	}

	private NamedQuery findNamedQuery(QueryContainer container, int offset, int[] position) {

		for (Iterator<OrmNamedQuery> queries = container.namedQueries(); queries.hasNext(); ) {
			OrmNamedQuery namedQuery = queries.next();
			TextRange textRange = namedQuery.getQueryTextRange();

			if (textRange.touches(offset)) {
				position[0] = offset - textRange.getOffset();
				return namedQuery;
			}
		}

		return null;
	}

	private String jpqlQuery(NamedQuery namedQuery, int position) {

		String query = namedQuery.getQuery();

		if (query == null) {
			query = StringTools.EMPTY_STRING;
		}

		// The NamedQuery's query does not have the trailing whitespace, add them
		if (query.length() < position) {
			query = StringTools.pad(query, position, ' ');
		}

		return query;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	String modifyJpqlQuery(String jpqlQuery, int[] position) {
		return ExpressionTools.unescape(jpqlQuery, position);
	}

	private NamedQuery namedQuery(JpaFile jpaFile, int offset, int[] position) {

		for (JpaStructureNode node : jpaFile.getRootStructureNodes()) {
			NamedQuery namedQuery = findNamedQuery(node, offset, position);
			if (namedQuery != null) {
				return namedQuery;
			}
		}

		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.persistence.jpa.jpql.ContentAssistProposals;
import org.eclipse.persistence.jpa.jpql.ResultQuery;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

/**
 * The concrete implementation of a {@link org.eclipse.jface.text.contentassist.ICompletionProposal
 * ICompletionProposal} that adds relevance and toggling the completion insertion property behavior.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
final class JpqlCompletionProposal implements ICompletionProposal {

	private String actualQuery;
	private String additionalInfo;
	private ContentAssistProposals proposals;
	private int cursorOffset;
	private String displayString;
	private boolean escapeCharacters;
	private Image image;
	private String jpqlQuery;
	private NamedQuery namedQuery;
	private int offset;
	private int position;
	private String proposal;
	private ResultQuery result;
	private boolean toggleCompletion;

	JpqlCompletionProposal(ContentAssistProposals proposals,
	                       String proposal,
	                       String displayString,
	                       String additionalInfo,
	                       Image image,
	                       NamedQuery namedQuery,
	                       String actualQuery,
	                       String jpqlQuery,
	                       int offset,
	                       int position,
	                       int cursorOffset,
	                       boolean escapeCharacters) {

		super();

		this.image              = image;
		this.offset             = offset;
		this.position           = position;
		this.proposal           = proposal;
		this.jpqlQuery          = jpqlQuery;
		this.namedQuery         = namedQuery;
		this.actualQuery        = actualQuery;
		this.cursorOffset       = cursorOffset;
		this.displayString      = displayString;
		this.additionalInfo     = additionalInfo;
		this.escapeCharacters   = escapeCharacters;
		this.proposals = proposals;
	}

	/**
	 * {@inheritDoc}
	 */
	public void apply(IDocument document) {
		try {
			ResultQuery result = buildResult();
			document.replace(offset, actualQuery.length(), result.getQuery());
		}
		catch (BadLocationException e) {
			// Ignore
		}
	}

	private ResultQuery buildResult() {
		if (result == null) {
			if (escapeCharacters) {
				result = proposals.buildEscapedQuery(
					jpqlQuery,
					proposal,
					position,
					isCompletionInserts() ^ toggleCompletion
				);
			}
			else {
				result = proposals.buildQuery(
					jpqlQuery,
					proposal,
					position,
					isCompletionInserts() ^ toggleCompletion
				);
			}
		}
		return result;
	}

	/**
	 * {@inheritDoc}
	 */
	public String getAdditionalProposalInfo() {
		return additionalInfo;
	}

	/**
	 * {@inheritDoc}
	 */
	public IContextInformation getContextInformation() {
		return null; // Not needed, this is legacy API
	}

	/**
	 * {@inheritDoc}
	 */
	public String getDisplayString() {
		return displayString;
	}

	/**
	 * {@inheritDoc}
	 */
	public Image getImage() {
		return image;
	}

	/**
	 * {@inheritDoc}
	 */
	public Point getSelection(IDocument document) {
		ResultQuery result = buildResult();
		return new Point(offset + result.getPosition() + cursorOffset, 0);
	}

	private boolean isCompletionInserts() {
		IJavaProject javaProject = namedQuery.getJpaProject().getJavaProject();
		String value = PreferenceConstants.getPreference(PreferenceConstants.CODEASSIST_INSERT_COMPLETION, javaProject);
		return Boolean.valueOf(value);
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.jpa.core.context.NamedQuery;
import org.eclipse.jpt.jpa.core.internal.jpql.JpaJpqlQueryHelper;
import org.eclipse.jpt.jpa.ui.JptJpaUiPlugin;
import org.eclipse.jpt.jpa.ui.internal.JptUiIcons;
import org.eclipse.persistence.jpa.internal.jpql.parser.Expression;
import org.eclipse.persistence.jpa.internal.jpql.parser.IdentifierRole;
import org.eclipse.persistence.jpa.internal.jpql.parser.JPQLExpression;
import org.eclipse.persistence.jpa.jpql.ContentAssistProposals;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IMapping;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;

import static org.eclipse.jpt.common.utility.internal.CollectionTools.*;

/**
 * The abstract definition of JPQL content assist support.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings({"nls", "restriction"})
abstract class JpqlCompletionProposalComputer<T> {

	/**
	 * The current value of the query element.
	 */
	String actualQuery;

	/**
	 * The provider of content assist items based on the position of the cursor within the JPQL query.
	 */
	ContentAssistProposals contentAssistProposals;

	/**
	 * The local registry containing the images used to display the possible proposals. The registry is
	 * disposed when the session ended.
	 */
	private ImageRegistry imageRegistry;

	/**
	 * The same value as {@link #actualQuery} or the modified query that was used by the Hermes parser.
	 */
	String jpqlQuery;

	/**
	 * The JPA model object that is used to access the Java project.
	 */
	NamedQuery namedQuery;

	/**
	 * The start position of the query within the document.
	 */
	int offset;

	/**
	 * The position of the cursor within {@link #actualQuery}.
	 */
	int position;

	/**
	 * This helper is responsible to retrieve the possible proposals to complete or to add more
	 * information to a JPQL based on the position of the cursor.
	 */
	JpaJpqlQueryHelper queryHelper;

	/**
	 * Creates a new <code>JpqlCompletionProposalComputer</code>.
	 */
	public JpqlCompletionProposalComputer() {
		super();
	}

	/**
	 * Adds completion proposals for the abstract schema names that are possible proposals.
	 *
	 * @param proposals The list used to store the new completion proposals
	 */
	private void addAbstractSchemaNames(List<T> proposals) {
		for (IEntity abstractSchemaType : sortByNames(contentAssistProposals.abstractSchemaTypes())) {
			proposals.add(buildAbstractSchemaNameProposal(abstractSchemaType));
		}
	}

	/**
	 * Adds completion proposals for the identification variables that are possible proposals.
	 *
	 * @param proposals The list used to store the new completion proposals
	 */
	private void addIdentificationVariables(List<T> proposals) {
		for (String variable : sort(contentAssistProposals.identificationVariables())) {
			proposals.add(buildIdentificationVariableProposal(variable));
		}
	}

	/**
	 * Adds completion proposals for the JPQL identifiers that are possible proposals.
	 *
	 * @param proposals The list used to store the new completion proposals
	 */
	private void addIdentifiers(List<T> proposals) {
		for (String identifier : sort(contentAssistProposals.identifiers())) {
			proposals.add(buildIdentifierProposal(identifier));
		}
	}

	private String additionalInfo(String proposal) {
		return JpqlIdentifierMessages.localizedMessage(proposal);
	}

	/**
	 * Adds completion proposals for the state fields and association fields that are possible proposals.
	 *
	 * @param proposals The list used to store the new completion proposals
	 */
	private void addMappings(List<T> proposals) {
		for (IMapping mapping : sort(contentAssistProposals.mappings())) {
			proposals.add(buildMappingProposal(mapping));
		}
	}

	private T buildAbstractSchemaNameProposal(IEntity abstractSchemaType) {
		String proposal = abstractSchemaType.getName();
		return buildProposal(proposal, proposal, entityImage());
	}

	private Comparator<IEntity> buildEntityNameComparator() {
		return new Comparator<IEntity>() {
			public int compare(IEntity entity1, IEntity entity2) {
				return entity1.getName().compareTo(entity2.getName());
			}
		};
	}

	private String buildIdentificationVariableDisplayString(String identificationVariable) {

		IEntity abstractSchemaType = contentAssistProposals.getAbstractSchemaType(identificationVariable);

		if (abstractSchemaType != null) {
			StringBuilder sb = new StringBuilder();
			sb.append(identificationVariable);
			sb.append(" : ");
			sb.append(abstractSchemaType.getName());
			identificationVariable = sb.toString();
		}

		return identificationVariable;
	}

	private T buildIdentificationVariableProposal(String proposal) {
		return buildProposal(
			proposal,
			buildIdentificationVariableDisplayString(proposal),
			identificationVariableImage()
		);
	}

	private T buildIdentifierProposal(String proposal) {

		String additionalInfo = additionalInfo(proposal);
		IdentifierRole role = JPQLExpression.identifierRole(proposal);
		boolean realFunction = (role == IdentifierRole.FUNCTION) && isRealFunction(proposal);
		int cursorOffset = 0;

		// For JPQL function, we add () to the display string, example: AVG()
		// But for TRUE, FALSE, etc, we don't add ()
		if (realFunction) {
			proposal += "()";
			cursorOffset--;
		}

		return buildProposal(
			proposal,
			proposal,
			additionalInfo,
			identifierImage(realFunction),
			cursorOffset
		);
	}

	private T buildMappingProposal(IMapping mapping) {
		String proposal = mapping.getName();
		return buildProposal(proposal, proposal, mappingImage(mapping));
	}

	private T buildProposal(String proposal, String displayString, Image image) {
		return buildProposal(proposal, displayString, null, image, 0);
	}

	/**
	 * Creates a new completion proposal for the given proposal.
	 *
	 * @param proposal A valid proposal that can be inserted into the query
	 * @param displayString The human readable string of the proposal
	 * @param additionalInfo Optional additional information about the proposal. The additional
	 * information will be presented to assist the user in deciding if the selected proposal is the
	 * desired choice
	 * @param image The image that represents the proposal
	 * @param cursorOffset An offset that moves the cursor backward or forward after it is adjusted
	 * based on the given proposal
	 * @return The completion proposal
	 */
	abstract T buildProposal(String proposal,
	                         String displayString,
	                         String additionalInfo,
	                         Image image,
	                         int cursorOffset);

	/**
	 * Creates the list of completion proposals based on the current content of the JPQL query and at
	 * the specified position.
	 *
	 * @param namedQuery The model object used to access the application metadata information
	 * @param actualQuery The model object may sometimes be out of sync with the actual content, the
	 * actual query is required for proper content assist
	 * @param offset The beginning of the string within the document
	 * @param position The position of the cursor within the query, which starts at the beginning of
	 * that query and not the document
	 * @return The list of completion proposals
	 */
	final List<T> buildProposals(NamedQuery namedQuery, String actualQuery, int offset, int position) {

		this.offset      = offset;
		this.actualQuery = actualQuery;
		this.namedQuery  = namedQuery;

		// It's possible the string has literal representation of the escape characters, if required,
		// convert them into actual escape characters and adjust the position accordingly
		int[] positions = { position };
		this.jpqlQuery  = modifyJpqlQuery(actualQuery, positions);
		this.position   = positions[0];

		// Gather the possible proposals
		this.queryHelper        = new JpaJpqlQueryHelper(namedQuery, jpqlQuery);
		this.contentAssistProposals = queryHelper.buildContentAssistProposals(positions[0]);

		// Create the proposals for those proposals
		List<T> proposals = new ArrayList<T>();
		addAbstractSchemaNames    (proposals);
		addIdentificationVariables(proposals);
		addIdentifiers            (proposals);
		addMappings               (proposals);

		return proposals;
	}

	final void checkCanceled(IProgressMonitor monitor) throws InterruptedException {
		if (monitor.isCanceled()) {
			throw new InterruptedException();
		}
	}

	private Image entityImage() {
		return getImage(JptUiIcons.ENTITY);
	}

	/**
	 * Returns the reason why this computer was unable to produce any completion proposals or
	 * context information.
	 *
	 * @return An error message or <code>null</code> if no error occurred
	 */
	public String getErrorMessage() {
		return null;
	}

	private Image getImage(String key) {
		ImageRegistry imageRegistry = getImageRegistry();
		Image image = imageRegistry.get(key);
		if (image == null) {
			imageRegistry.put(key, getImageDescriptor(key));
			image = imageRegistry.get(key);
		}
		return image;
	}

	private ImageDescriptor getImageDescriptor(String key) {
		return JptJpaUiPlugin.getImageDescriptor(key);
	}

	private ImageRegistry getImageRegistry() {
		if (imageRegistry == null) {
			imageRegistry = new ImageRegistry(Display.getCurrent());
		}
		return imageRegistry;
	}

	private Image identificationVariableImage() {
		return getImage(JptUiIcons.JPQL_VARIABLE);
	}

	private Image identifierImage(boolean function) {

		if (function) {
			return getImage(JptUiIcons.JPQL_FUNCTION);
		}

		return getImage(JptUiIcons.JPQL_IDENTIFIER);
	}

	private boolean isRealFunction(String identifier) {
		return identifier != Expression.TRUE         &&
		       identifier != Expression.FALSE        &&
		       identifier != Expression.NULL         &&
		       identifier != Expression.CURRENT_DATE &&
		       identifier != Expression.CURRENT_TIME &&
		       identifier != Expression.CURRENT_TIMESTAMP;
	}

	private Image mappingImage(IMapping mapping) {
		switch (mapping.getMappingType()) {
			case BASIC:               return getImage(JptUiIcons.BASIC);
			case BASIC_COLLECTION:    return getImage(JptUiIcons.ELEMENT_COLLECTION);
			case BASIC_MAP:           return getImage(JptUiIcons.ELEMENT_COLLECTION);
			case ELEMENT_COLLECTION:  return getImage(JptUiIcons.ELEMENT_COLLECTION);
			case EMBEDDED:            return getImage(JptUiIcons.EMBEDDED);
			case EMBEDDED_ID:         return getImage(JptUiIcons.EMBEDDED_ID);
			case ID:                  return getImage(JptUiIcons.ID);
			case MANY_TO_MANY:        return getImage(JptUiIcons.MANY_TO_MANY);
			case MANY_TO_ONE:         return getImage(JptUiIcons.MANY_TO_ONE);
			case ONE_TO_MANY:         return getImage(JptUiIcons.ONE_TO_MANY);
			case ONE_TO_ONE:          return getImage(JptUiIcons.ONE_TO_ONE);
			case TRANSFORMATION:      return getImage(JptUiIcons.BASIC);      // TODO
			case VARIABLE_ONE_TO_ONE: return getImage(JptUiIcons.ONE_TO_ONE); // TODO
			case VERSION:             return getImage(JptUiIcons.VERSION);
			default:                  return getImage(JptUiIcons.TRANSIENT);
		}
	}

	/**
	 * In some context, the given JPQL query needs to be modified before it is parsed.
	 *
	 * @param jpqlQuery The JPQL query to keep unchanged or to modify before parsing it
	 * @param position The position of the cursor within the JPQL query, which needs to be updated if
	 * the query is modified
	 * @return The given JPQL query or a modified version that will be parsed
	 */
	String modifyJpqlQuery(String jpqlQuery, int[] position) {
		return jpqlQuery;
	}

	/**
	 * Informs the computer that a content assist session has ended.
	 */
	public void sessionEnded() {

		offset      = -1;
		position    = -1;
		namedQuery  = null;
		actualQuery = null;
		queryHelper = null;
		contentAssistProposals = null;

		if (imageRegistry != null) {
			imageRegistry.dispose();
		}
	}

	/**
	 * Informs the computer that a content assist session has started.
	 */
	public void sessionStarted() {
		// Nothing to do
	}

	private Iterable<IEntity> sortByNames(Iterable<IEntity> abstractSchemaTypes) {
		return CollectionTools.sort(abstractSchemaTypes, buildEntityNameComparator());
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.osgi.util.NLS;
import org.eclipse.persistence.jpa.internal.jpql.parser.Expression;

/**
 * The localized messages describing the JPQL identifiers.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings({"nls", "restriction"})
final class JpqlIdentifierMessages extends NLS {

	// JPA 1.0 identifiers
	public static String ABS;
	public static String ALL;
	public static String ANY;
	public static String ASC;
	public static String AVG;
	public static String BETWEEN;
	public static String BOTH;
	public static String CONCAT;
	public static String COUNT;
	public static String CURRENT_DATE;
	public static String CURRENT_TIME;
	public static String CURRENT_TIMESTAMP;
	public static String DELETE_FROM;
	public static String DESC;
	public static String DISTINCT;
	public static String ESCAPE;
	public static String EXISTS;
	public static String FROM;
	public static String GROUP_BY;
	public static String HAVING;
	public static String IN;
	public static String IS_EMPTY;
	public static String IS_NULL;
	public static String JOIN;
	public static String JOIN_FETCH;
	public static String LEADING;
	public static String LENGTH;
	public static String LIKE;
	public static String LOCATE;
	public static String LOWER;
	public static String MAX;
	public static String MEMBER;
	public static String MIN;
	public static String MOD;
	public static String NEW;
	public static String OBJECT;
	public static String ORDER_BY;
	public static String SELECT;
	public static String SIZE;
	public static String SOME;
	public static String SQRT;
	public static String SUBSTRING;
	public static String SUM;
	public static String TRAILING;
	public static String TRIM;
	public static String UPDATE;
	public static String UPPER;
	public static String WHERE;

	// JPA 2.0 identifiers
//	public static String CASE;
	public static String COALESCE;
//	public static String ENTRY;
	public static String INDEX;
//	public static String KEY;
	public static String NULLIF;
	public static String TYPE;
//	public static String VALUE;

	// EclipseLink identifiers
//	public static String FUNC;
//	public static String TREAT;

	// Reserved JPQL identifiers
	public static String BIT_LENGTH;
	public static String CHAR_LENGTH;
	public static String CHARACTER_LENGTH;
	public static String CLASS;
	public static String POSITION;
	public static String UNKNOWN;

	static {
		NLS.initializeMessages("jpt_ui_jpql_identifiers", JpqlIdentifierMessages.class);
	}

	JpqlIdentifierMessages() {
		super();
		throw new UnsupportedOperationException();
	}

	private static Map<String, String> registeredIdentifers;

	private static Map<String, String> buildRegisteredIdentifers() {

		Map<String, String> identifiers = new HashMap<String, String>();

		identifiers.put(Expression.IS_NOT_EMPTY,  Expression.IS_EMPTY);
		identifiers.put(Expression.IS_NOT_NULL,   Expression.IS_NULL);
		identifiers.put(Expression.MEMBER_OF,     Expression.MEMBER);
		identifiers.put(Expression.NOT_IN,        Expression.IN);
		identifiers.put(Expression.NOT_BETWEEN,   Expression.BETWEEN);
		identifiers.put(Expression.NOT_MEMBER,    Expression.MEMBER);
		identifiers.put(Expression.NOT_MEMBER_OF, Expression.MEMBER);

		identifiers.put(Expression.INNER_JOIN,      Expression.JOIN);
		identifiers.put(Expression.LEFT_JOIN,       Expression.JOIN);
		identifiers.put(Expression.LEFT_OUTER_JOIN, Expression.JOIN);

		identifiers.put(Expression.INNER_JOIN_FETCH,      Expression.JOIN_FETCH);
		identifiers.put(Expression.LEFT_JOIN_FETCH,       Expression.JOIN_FETCH);
		identifiers.put(Expression.LEFT_OUTER_JOIN_FETCH, Expression.JOIN_FETCH);

		return identifiers;
	}

	/**
	 * Converts the given JPQL identifier to the shortest form that is used to map the localized
	 * message. If the identifier is <b>NOT MEMBER</b> for instance, then it needs to be converted
	 * to <b>MEMBER</b> since that's the identifier used to map the localize message.
	 *
	 * @param identifier The JPQL identifier to convert, if needed
	 * @return Either the given JPQL identifier or its counterpart that is used to map the localized
	 * message
	 */
	private static String convertIdentifier(String identifier) {
		identifier = registeredIdentifer(identifier);
		identifier = identifier.replace(" ", "_");
		return identifier;
	}

	/**
	 * Retrieves the localized message for the given string value, if it's a JPQL identifier.
	 *
	 * @param identifier The JPQL identifier for which its localized description is needed
	 * @return The localized message describing the given JPQL identifier or <code>null</code> if the
	 * given choice is not an identifier
	 */
	static String localizedMessage(String identifier) {
		try {
			identifier = convertIdentifier(identifier);
			Field constant = JpqlIdentifierMessages.class.getField(identifier);
			return (String) constant.get(null);
		}
		catch (Exception e) {
			// The choice is not a JPQL identifier
			return null;
		}
	}

	private static String registeredIdentifer(String identifier) {
		String another = registeredIdentifers().get(identifier);
		if (another != null) {
			return another;
		}
		return identifier;
	}

	private static Map<String, String> registeredIdentifers() {
		if (registeredIdentifers == null) {
			registeredIdentifers = buildRegisteredIdentifers();
		}
		return registeredIdentifers;
	}
}




/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation
 *
 ******************************************************************************/
package org.eclipse.jpt.jpa.ui.internal.jpql;

import org.eclipse.jface.text.IUndoManager;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.TransferData;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.events.MenuListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.ui.internal.WorkbenchMessages;

/**
 * This handler adds a context menu onto a {@link StyledText} which have the default actions dealing
 * with text editing: Undo | Cut, Copy, Paste, Delete | Select All.
 *
 * @version 3.0
 * @since 3.0
 * @author Pascal Filion
 */
@SuppressWarnings("restriction")
public final class TextTransferHandler {

	private MenuItem copyMenuItem;
	private MenuItem cutMenuItem;
	private MenuItem deleteMenuItem;
	private MenuItem pasteMenuItem;
	private Menu popup;
	private MenuItem selectAllMenuItem;
	private StyledText styledText;
	private IUndoManager undoManager;
	private MenuItem undoMenuItem;

	private TextTransferHandler(StyledText styledText, IUndoManager undoManager) {
		super();
		this.styledText  = styledText;
		this.undoManager = undoManager;
	}

	/**
	 * Installs a context menu onto the given {@link StyledText} which have the default actions
	 * dealing with text editing: Undo | Cut, Copy, Paste, Delete | Select All.
	 *
	 * @param styledText The widget for which a context menu will be added
	 * @param undoManager The manager to undo keystrokes
	 */
	public static void installContextMenu(StyledText styledText, IUndoManager undoManager) {
		TextTransferHandler handler = new TextTransferHandler(styledText, undoManager);
		handler.installPopup();
	}

	private SelectionAdapter buildCopySelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				styledText.copy();
			}
		};
	}

	private SelectionListener buildCutSelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				styledText.cut();
			}
		};
	}

	private SelectionListener buildDeleteSelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				Point selection = styledText.getSelection();
				styledText.replaceTextRange(selection.x, selection.y - selection.x, StringTools.EMPTY_STRING);
			}
		};
	}

	private MenuListener buildMenuListener() {
		return new MenuListener() {
			public void menuHidden(MenuEvent e) {
			}
			public void menuShown(MenuEvent e) {
				update();
			}
		};
	}

	private SelectionListener buildPasteSelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				styledText.paste();
			}
		};
	}

	private SelectionListener buildSelectAllSelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				styledText.selectAll();
			}
		};
	}

	private SelectionListener buildUndoSelectionListener() {
		return new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				undoManager.undo();
			}
		};
	}

	private boolean canCopy() {
		Point selection = styledText.getSelection();
		return selection.x != selection.y;
	}

	private boolean canCut() {
		Point selection = styledText.getSelection();
		return selection.x != selection.y;
	}

	private boolean canDelete() {
		Point selection = styledText.getSelection();
		return selection.x != selection.y;
	}

	private boolean canPaste() {

		Clipboard clipboard = new Clipboard(styledText.getDisplay());
		boolean canPaste = false;

		for (TransferData data : clipboard.getAvailableTypes()) {
			if (TextTransfer.getInstance().isSupportedType(data)) {
				canPaste = true;
				break;
			}
		}

		clipboard.dispose();
		return canPaste;
	}

	private boolean canSelectAll() {
		Point selection = styledText.getSelection();
		String text = styledText.getText();
		return (selection.y - selection.x) != text.length();
	}

	private void installPopup() {

		popup = new Menu(styledText.getShell(), SWT.POP_UP);
		popup.addMenuListener(buildMenuListener());
		styledText.setMenu(popup);

		populatePopup();
	}

	private void populatePopup() {

		// Undo
		undoMenuItem = new MenuItem(popup, SWT.PUSH);
		undoMenuItem.setText(WorkbenchMessages.Workbench_undo);
		undoMenuItem.addSelectionListener(buildUndoSelectionListener());

		new MenuItem(popup, SWT.SEPARATOR);

		// Cut
		cutMenuItem = new MenuItem(popup, SWT.PUSH);
		cutMenuItem.setText(WorkbenchMessages.Workbench_cut);
		cutMenuItem.addSelectionListener(buildCutSelectionListener());

		// Copy
		copyMenuItem = new MenuItem(popup, SWT.PUSH);
		copyMenuItem.setText(WorkbenchMessages.Workbench_copy);
		copyMenuItem.addSelectionListener(buildCopySelectionListener());

		// Paste
		pasteMenuItem = new MenuItem(popup, SWT.PUSH);
		pasteMenuItem.setText(WorkbenchMessages.Workbench_paste);
		pasteMenuItem.addSelectionListener(buildPasteSelectionListener());

		// Delete
		deleteMenuItem = new MenuItem(popup, SWT.PUSH);
		deleteMenuItem.setText(WorkbenchMessages.Workbench_delete);
		deleteMenuItem.addSelectionListener(buildDeleteSelectionListener());

		new MenuItem(popup, SWT.SEPARATOR);

		// Select All
		selectAllMenuItem = new MenuItem(popup, SWT.PUSH);
		selectAllMenuItem.setText(WorkbenchMessages.Workbench_selectAll);
		selectAllMenuItem.addSelectionListener(buildSelectAllSelectionListener());
	}

	private void update() {
		deleteMenuItem   .setEnabled(canDelete());
		copyMenuItem     .setEnabled(canCopy());
		cutMenuItem      .setEnabled(canCut());
		pasteMenuItem    .setEnabled(canPaste());
		selectAllMenuItem.setEnabled(canSelectAll());
		undoMenuItem     .setEnabled(undoManager.undoable());
	}
}





	/**
	 * Default severity levels are stored here,  ERROR is the default default so only need
	 * to include WARNING, INFO, IGNORE in this Map. These will be displayed if neither the project
	 * or workspace preference applies.
	 * <br> key is the preferenceKey which is also the validation message key @see JpaValidationMessages.
	 * <br> value is a severity level - @see JpaValidationPreferences#ERROR WARNING INFO IGNORE
	 */
	private Map<String, String> defaultSeverities;

	/**
	 * The list of <code>Combo</code>s is cached in order to perform a revert of
	 * the properties.

	private void addAttributeLevelCategory(Composite parent) {

		parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.ATTRIBUTE_LEVEL_CATEGORY);

		addLabeledCombo(
			parent, JptUiValidationPreferenceMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME,
			JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME);

			JpaValidationMessages.ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);

		parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);

		addLabeledCombo(
			parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY,
			JpaValidationMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY);

			JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);
		addLabeledCombo(
			parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED,
			JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);
	}

	private void addDatabaseCategory(Composite parent) {

	}

	private void addTableCategory(Composite parent) {

		parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.TABLE_CATEGORY);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_CATALOG,                                            					JpaValidationMessages.TABLE_UNRESOLVED_CATALOG);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_SCHEMA,                                             					JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_NAME,                                               					JpaValidationMessages.TABLE_UNRESOLVED_NAME);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA,                                 JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME,                                   JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME);
	}

	private void addColumnCategory(Composite parent) {
		parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.COLUMN_CATEGORY);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_TABLE_NOT_VALID,                                      							JpaValidationMessages.COLUMN_TABLE_NOT_VALID);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_TABLE,                                             					JpaValidationMessages.COLUMN_UNRESOLVED_TABLE);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_NAME,                                              					JpaValidationMessages.COLUMN_UNRESOLVED_NAME);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID, 													JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID);
	}

	private void addOverridesCategory(Composite parent) {

		parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.OVERRIDES_CATEGORY);


		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, 				JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);


		parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME,                  									JpaValidationMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME);

		addLabeledCombo(parent, JptUiValidationPreferenceMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME, JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR, JpaValidationMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.QUERY_DUPLICATE_NAME,                 JpaValidationMessages.QUERY_DUPLICATE_NAME);
		addLabeledCombo(parent, JptUiValidationPreferenceMessages.JPQL_QUERY_VALIDATION,                JpaValidationMessages.JPQL_QUERY_VALIDATION);
	}

	private Composite addExpandableSection(Composite parent, String text) {
		return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false));
	}

	private Composite addSubExpandableSection(Composite parent, String text) {
		return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false, 2, 1));
	}

		String preference = this.defaultSeverities.get(preferenceKey);
		return preference == null ? JpaValidationPreferences.ERROR : preference;
	}

	protected int convertPreferenceValueToComboIndex(String preferenceValue) {
		if (JpaValidationPreferences.ERROR.equals(preferenceValue)) {
			return ERROR_INDEX;

			revertToDefault();
		}
	}

	@Override
	protected void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {
		super.enableProjectSpecificSettings(useProjectSpecificSettings);

			//      "otherwise the 'enable project specific settings' checkbox is being pressed")
			return;
		}

		this.hasProjectSpecificPreferences = Boolean.valueOf(useProjectSpecificSettings);

		//set all specified workspace preferences in the project preferences
		if (useProjectSpecificSettings){
			this.overrideWorkspacePreferences();

				preference = getDefaultPreferenceValue(preferenceKey);
			}
			combo.select(convertPreferenceValueToComboIndex(preference));
			//UI will show the defaults from the workspace, but set all preferences
			//to null so they will be deleted from project preferences
			this.severityLevels.put(preferenceKey, null);
		}

			}
		}
	}

	// ********** OK/Revert/Apply behavior **********

	@Override

		}
		catch (InterruptedException ex) {
			return false;
		}
		catch (InvocationTargetException ex) {
			throw new RuntimeException(ex.getTargetException());
		}

Return to bug 337930

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/common/ui/WidgetFactory.java (-3 / +13 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008 Oracle. All rights reserved.	2	* Copyright (c) 2008, 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the	3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution	4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.	5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
Lines 10-15 Link Here
10	package org.eclipse.jpt.common.ui;	10	package org.eclipse.jpt.common.ui;
11		11
12	import org.eclipse.swt.custom.CCombo;	12	import org.eclipse.swt.custom.CCombo;
		13	import org.eclipse.swt.custom.StyledText;
13	import org.eclipse.swt.widgets.Button;	14	import org.eclipse.swt.widgets.Button;
14	import org.eclipse.swt.widgets.Combo;	15	import org.eclipse.swt.widgets.Combo;
15	import org.eclipse.swt.widgets.Composite;	16	import org.eclipse.swt.widgets.Composite;
Lines 35-42 Link Here
35	* adopters on the understanding that any code that uses this API will almost	36	* adopters on the understanding that any code that uses this API will almost
36	* certainly be broken (repeatedly) as the API evolves.	37	* certainly be broken (repeatedly) as the API evolves.
37	*	38	*
38	* @version 2.0	39	* @version 3.0
39	* @since 2.0	40	* @since 3.0
40	*/	41	*/
41	public interface WidgetFactory {	42	public interface WidgetFactory {
42		43
Lines 163-168 Link Here
163	*	164	*
164	* @param parent The parent container	165	* @param parent The parent container
165	* @param parent The number of lines the text area should display	166	* @param parent The number of lines the text area should display
		167	* @return A new <code>StyledText</code>
		168	*/
		169	StyledText createMultiLineStyledText(Composite parent);
		170
		171	/**
		172	* Creates a new editable text area.
		173	*
		174	* @param parent The parent container
		175	* @param parent The number of lines the text area should display
166	* @return A new <code>Text</code>	176	* @return A new <code>Text</code>
167	*/	177	*/
168	Text createMultiLineText(Composite parent);	178	Text createMultiLineText(Composite parent);

Lines 10-16 Link Here

(-)src/org/eclipse/jpt/common/ui/internal/utility/swt/SWTTools.java (-1 / +9 lines)
10	package org.eclipse.jpt.common.ui.internal.utility.swt;	10	package org.eclipse.jpt.common.ui.internal.utility.swt;
11		11
12	import java.util.Arrays;	12	import java.util.Arrays;
13
14	import org.eclipse.jpt.common.utility.internal.BitTools;	13	import org.eclipse.jpt.common.utility.internal.BitTools;
15	import org.eclipse.jpt.common.utility.internal.StringConverter;	14	import org.eclipse.jpt.common.utility.internal.StringConverter;
16	import org.eclipse.jpt.common.utility.internal.model.value.StaticCollectionValueModel;	15	import org.eclipse.jpt.common.utility.internal.model.value.StaticCollectionValueModel;
Lines 21-26 Link Here
21	import org.eclipse.jpt.common.utility.model.value.WritableCollectionValueModel;	20	import org.eclipse.jpt.common.utility.model.value.WritableCollectionValueModel;
22	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;	21	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
23	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
		23	import org.eclipse.swt.custom.StyledText;
24	import org.eclipse.swt.widgets.Button;	24	import org.eclipse.swt.widgets.Button;
25	import org.eclipse.swt.widgets.Combo;	25	import org.eclipse.swt.widgets.Combo;
26	import org.eclipse.swt.widgets.Control;	26	import org.eclipse.swt.widgets.Control;
Lines 68-73 Link Here
68	new TextFieldModelBinding(textModel, textField);	68	new TextFieldModelBinding(textModel, textField);
69	}	69	}
70		70
		71	/**
		72	* Bind the specified text model to the specified text field.
		73	*/
		74	public static <E> void bind(WritablePropertyValueModel<String> textModel, StyledText textField) {
		75	// the new binding will add itself as a listener to the text model and the text field
		76	new StyledTextFieldModelBinding(textModel, textField);
		77	}
		78
71		79
72	// ******** list box ********	80	// ******** list box ********
73		81

Added Link Here

(-)src/org/eclipse/jpt/common/ui/internal/utility/swt/StyledTextFieldModelBinding.java (+196 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 Oracle. All rights reserved.
3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0, which accompanies this distribution
5	* and is available at http://www.eclipse.org/legal/epl-v10.html.
6	*
7	* Contributors:
8	* Oracle - initial API and implementation
9	******************************************************************************/
10	package org.eclipse.jpt.common.ui.internal.utility.swt;
11
12	import org.eclipse.jpt.common.ui.internal.listeners.SWTPropertyChangeListenerWrapper;
13	import org.eclipse.jpt.common.utility.internal.StringTools;
14	import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent;
15	import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
16	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
17	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
18	import org.eclipse.swt.custom.StyledText;
19	import org.eclipse.swt.events.DisposeEvent;
20	import org.eclipse.swt.events.DisposeListener;
21	import org.eclipse.swt.events.ModifyEvent;
22	import org.eclipse.swt.events.ModifyListener;
23
24	/**
25	* This binding can be used to keep a styled text field
26	* synchronized with a model text/string.
27	*
28	* @see WritablePropertyValueModel
29	* @see StyledText
30	*/
31	@SuppressWarnings("nls")
32	class StyledTextFieldModelBinding {
33
34	/**
35	* The text model we keep synchronized with the text field.
36	*/
37	private final WritablePropertyValueModel<String> textModel;
38
39	/**
40	* A listener that allows us to synchronize the text field's contents with
41	* the text model.
42	*/
43	private final PropertyChangeListener textModelChangeListener;
44
45	/**
46	* The text field we keep synchronized with the text model.
47	*/
48	private final StyledText textField;
49
50	/**
51	* A listener that allows us to synchronize our text model
52	* with the text field's contents.
53	*/
54	private final ModifyListener textFieldModifyListener;
55
56	/**
57	* A listener that allows us to stop listening to stuff when the text field
58	* is disposed.
59	*/
60	private final DisposeListener textFieldDisposeListener;
61
62	/**
63	* Hmm...
64	*/
65	private boolean settingTextFieldText = false;
66
67
68	// ******** constructor ********
69
70	/**
71	* Constructor - the text model and text field are required.
72	*/
73	StyledTextFieldModelBinding(WritablePropertyValueModel<String> textModel, StyledText textField) {
74	super();
75	if ((textModel == null) \|\| (textField == null)) {
76	throw new NullPointerException();
77	}
78	this.textModel = textModel;
79	this.textField = textField;
80
81	this.textModelChangeListener = this.buildTextModelChangeListener();
82	this.textModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.textModelChangeListener);
83
84	this.textFieldModifyListener = this.buildTextFieldModifyListener();
85	this.textField.addModifyListener(this.textFieldModifyListener);
86
87	this.textFieldDisposeListener = this.buildTextFieldDisposeListener();
88	this.textField.addDisposeListener(this.textFieldDisposeListener);
89
90	this.setTextFieldText(textModel.getValue());
91	}
92
93
94	// ******** initialization ********
95
96	private PropertyChangeListener buildTextModelChangeListener() {
97	return new SWTPropertyChangeListenerWrapper(this.buildTextModelChangeListener_());
98	}
99
100	private PropertyChangeListener buildTextModelChangeListener_() {
101	return new PropertyChangeListener() {
102	public void propertyChanged(PropertyChangeEvent event) {
103	StyledTextFieldModelBinding.this.textModelChanged(event);
104	}
105	@Override
106	public String toString() {
107	return "text listener";
108	}
109	};
110	}
111
112	private ModifyListener buildTextFieldModifyListener() {
113	return new ModifyListener() {
114	public void modifyText(ModifyEvent event) {
115	StyledTextFieldModelBinding.this.textFieldModified();
116	}
117	@Override
118	public String toString() {
119	return "text field modify listener";
120	}
121	};
122	}
123
124	private DisposeListener buildTextFieldDisposeListener() {
125	return new DisposeListener() {
126	public void widgetDisposed(DisposeEvent event) {
127	StyledTextFieldModelBinding.this.textFieldDisposed();
128	}
129	@Override
130	public String toString() {
131	return "text field dispose listener";
132	}
133	};
134	}
135
136
137	// ******** text model events ********
138
139	/* CU private */ void textModelChanged(PropertyChangeEvent event) {
140	if ( ! this.textField.isDisposed()) { // ???
141	this.setTextFieldText((String) event.getNewValue());
142	}
143	}
144
145	private void setTextFieldText(String text) {
146	// the text model can be null, but the text field cannot
147	this.setTextFieldText_((text == null) ? "" : text);
148	}
149
150	private void setTextFieldText_(String text) {
151	if ( ! text.equals(this.textField.getText())) { // ???
152	this.setTextFieldText__(text);
153	}
154	}
155
156	private void setTextFieldText__(String text) {
157	this.settingTextFieldText = true;
158	try {
159	this.textField.setText(text);
160	} finally {
161	this.settingTextFieldText = false;
162	}
163	}
164
165
166	// ******** text field events ********
167
168	/* CU private */ void textFieldModified() {
169	if ( ! this.settingTextFieldText) {
170	this.setTextModelText(this.textField.getText());
171	}
172	}
173
174	private void setTextModelText(String text) {
175	if ( ! text.equals(this.textModel.getValue())) { // ???
176	this.textModel.setValue(text);
177	}
178	}
179
180	/* CU private */ void textFieldDisposed() {
181	// the text field is not yet "disposed" when we receive this event
182	// so we can still remove our listeners
183	this.textField.removeDisposeListener(this.textFieldDisposeListener);
184	this.textField.removeModifyListener(this.textFieldModifyListener);
185	this.textModel.removePropertyChangeListener(PropertyValueModel.VALUE, this.textModelChangeListener);
186	}
187
188
189	// ******** standard methods ********
190
191	@Override
192	public String toString() {
193	return StringTools.buildToStringFor(this, this.textModel);
194	}
195
196	}

Lines 25-30 Link Here

(-)META-INF/MANIFEST.MF (+2 lines)
25	org.eclipse.jst.common.project.facet.core;bundle-version="[1.3.100,2.0.0)",	25	org.eclipse.jst.common.project.facet.core;bundle-version="[1.3.100,2.0.0)",
26	org.eclipse.jst.j2ee;bundle-version="[1.1.200,2.0.0)",	26	org.eclipse.jst.j2ee;bundle-version="[1.1.200,2.0.0)",
27	org.eclipse.jst.j2ee.core;bundle-version="[1.1.200,2.0.0)",	27	org.eclipse.jst.j2ee.core;bundle-version="[1.1.200,2.0.0)",
		28	org.eclipse.persistence.jpa.jpql;bundle-version="1.0.0",
28	org.eclipse.wst.common.emf;bundle-version="[1.1.200,2.0.0)",	29	org.eclipse.wst.common.emf;bundle-version="[1.1.200,2.0.0)",
29	org.eclipse.wst.common.emfworkbench.integration;bundle-version="[1.1.200,2.0.0)",	30	org.eclipse.wst.common.emfworkbench.integration;bundle-version="[1.1.200,2.0.0)",
30	org.eclipse.wst.common.frameworks;bundle-version="[1.1.200,2.0.0)",	31	org.eclipse.wst.common.frameworks;bundle-version="[1.1.200,2.0.0)",
Lines 62-67 Link Here
62	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java;x-internal:=true,	63	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java;x-internal:=true,
63	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.binary;x-internal:=true,	64	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.binary;x-internal:=true,
64	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.source;x-internal:=true,	65	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.source;x-internal:=true,
		66	org.eclipse.jpt.jpa.core.internal.jpql;x-friends:="org.eclipse.jpt.jpa.ui",
65	org.eclipse.jpt.jpa.core.internal.libprov;x-internal:=true,	67	org.eclipse.jpt.jpa.core.internal.libprov;x-internal:=true,
66	org.eclipse.jpt.jpa.core.internal.libval;x-internal:=true,	68	org.eclipse.jpt.jpa.core.internal.libval;x-internal:=true,
67	org.eclipse.jpt.jpa.core.internal.operations;x-internal:=true,	69	org.eclipse.jpt.jpa.core.internal.operations;x-internal:=true,

Lines 32-37 Link Here

(-)META-INF/MANIFEST.MF (+2 lines)
32	org.eclipse.jst.common.project.facet.ui;bundle-version="[1.3.100,2.0.0)",	32	org.eclipse.jst.common.project.facet.ui;bundle-version="[1.3.100,2.0.0)",
33	org.eclipse.jst.j2ee;bundle-version="[1.1.200,2.0.0)",	33	org.eclipse.jst.j2ee;bundle-version="[1.1.200,2.0.0)",
34	org.eclipse.jst.j2ee.ui;bundle-version="[1.1.200,2.0.0)",	34	org.eclipse.jst.j2ee.ui;bundle-version="[1.1.200,2.0.0)",
		35	org.eclipse.persistence.jpa.jpql;bundle-version="1.0.0",
35	org.eclipse.ui.ide;bundle-version="[3.4.0,4.0.0)",	36	org.eclipse.ui.ide;bundle-version="[3.4.0,4.0.0)",
36	org.eclipse.ui.views.properties.tabbed;bundle-version="[3.4.0,4.0.0)",	37	org.eclipse.ui.views.properties.tabbed;bundle-version="[3.4.0,4.0.0)",
37	org.eclipse.ui.navigator;bundle-version="[3.3.100,4.0.0)",	38	org.eclipse.ui.navigator;bundle-version="[3.3.100,4.0.0)",
Lines 64-69 Link Here
64	org.eclipse.jpt.jpa.ui.internal.jpa2.persistence.connection;x-internal:=true,	65	org.eclipse.jpt.jpa.ui.internal.jpa2.persistence.connection;x-internal:=true,
65	org.eclipse.jpt.jpa.ui.internal.jpa2.persistence.options;x-internal:=true,	66	org.eclipse.jpt.jpa.ui.internal.jpa2.persistence.options;x-internal:=true,
66	org.eclipse.jpt.jpa.ui.internal.jpa2.platform.generic;x-internal:=true,	67	org.eclipse.jpt.jpa.ui.internal.jpa2.platform.generic;x-internal:=true,
		68	org.eclipse.jpt.jpa.ui.internal.jpql;x-internal:=true,
67	org.eclipse.jpt.jpa.ui.internal.listeners;x-internal:=true,	69	org.eclipse.jpt.jpa.ui.internal.listeners;x-internal:=true,
68	org.eclipse.jpt.jpa.ui.internal.menus;x-internal:=true,	70	org.eclipse.jpt.jpa.ui.internal.menus;x-internal:=true,
69	org.eclipse.jpt.jpa.ui.internal.navigator;x-internal:=true,	71	org.eclipse.jpt.jpa.ui.internal.navigator;x-internal:=true,

Lines 1-7 Link Here

(-)plugin.xml (-7 / +34 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.2"?>	2	<?eclipse version="3.2"?>
3	<!--	3	<!--
4	Copyright (c) 2007, 2010 Oracle. All rights reserved.	4	Copyright (c) 2007, 2011 Oracle. All rights reserved.
5	This program and the accompanying materials are made available under the	5	This program and the accompanying materials are made available under the
6	terms of the Eclipse Public License v1.0, which accompanies this distribution	6	terms of the Eclipse Public License v1.0, which accompanies this distribution
7	and is available at http://www.eclipse.org/legal/epl-v10.html.	7	and is available at http://www.eclipse.org/legal/epl-v10.html.
Lines 69-78 Link Here
69	<partition type="__dftl_partition_content_type"/>	69	<partition type="__dftl_partition_content_type"/>
70	<partition type="__java_string"/>	70	<partition type="__java_string"/>
71	</javaCompletionProposalComputer>	71	</javaCompletionProposalComputer>
72		72
73	</extension>	73	</extension>
74		74
75
76	<extension	75	<extension
77	point="org.eclipse.jdt.ui.javaCompletionProposalComputer"	76	point="org.eclipse.jdt.ui.javaCompletionProposalComputer"
78	id="jpaProposalCategory"	77	id="jpaProposalCategory"
Lines 80-87 Link Here
80	<proposalCategory	79	<proposalCategory
81	icon="$nl$/icons/full/eview16/jpa_perspective.gif"/>	80	icon="$nl$/icons/full/eview16/jpa_perspective.gif"/>
82	</extension>	81	</extension>
83		82
84		83	<extension
		84	point="org.eclipse.jdt.ui.javaCompletionProposalComputer"
		85	id="JpaJpqlCompletionProposalComputer">
		86
		87	<javaCompletionProposalComputer
		88	activate="true"
		89	categoryId="org.eclipse.jpt.jpa.ui.jpaProposalCategory"
		90	class="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlJavaCompletionProposalComputer">
		91	<partition type="__dftl_partition_content_type"/>
		92	<partition type="__java_string"/>
		93	</javaCompletionProposalComputer>
		94
		95	</extension>
		96
		97	<extension
		98	id="JpaJpqlSseCompletionProposal"
		99	point="org.eclipse.wst.sse.ui.completionProposal">
		100	<proposalComputer
		101	activate="true"
		102	categoryId="org.eclipse.wst.xml.ui.proposalCategory.xmlTags"
		103	class="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlSseCompletionProposalComputer"
		104	id="org.eclipse.jpt.jpa.ui.internal.jpql.JpaJpqlSseCompletionProposalComputer">
		105	<contentType
		106	id="org.eclipse.jpt.jpa.core.content.orm">
		107	</contentType>
		108	</proposalComputer>
		109	</extension>
		110
		111
85	<extension	112	<extension
86	point="org.eclipse.jpt.jpa.ui.jpaPlatformUis">	113	point="org.eclipse.jpt.jpa.ui.jpaPlatformUis">
87		114
Lines 94-100 Link Here
94	id="generic2_0.ui"	121	id="generic2_0.ui"
95	jpaPlatform="generic2_0"	122	jpaPlatform="generic2_0"
96	factoryClass="org.eclipse.jpt.jpa.ui.internal.jpa2.platform.generic.Generic2_0JpaPlatformUiFactory"/>	123	factoryClass="org.eclipse.jpt.jpa.ui.internal.jpa2.platform.generic.Generic2_0JpaPlatformUiFactory"/>
97		124
98	</extension>	125	</extension>
99		126
100		127

Added Link Here

(-)property_files/jpt_ui_jpql_identifiers.properties (+83 lines)
1	################################################################################
2	# Copyright (c) 2011 Oracle. All rights reserved.
3	# This program and the accompanying materials are made available under the
4	# terms of the Eclipse Public License v1.0, which accompanies this distribution
5	# and is available at http://www.eclipse.org/legal/epl-v10.html.
6	#
7	# Contributors:
8	# Oracle - initial API and implementation
9	################################################################################
10
11	# JPA 1.0 identifiers
12	ABS=The <b>ABS</b> function removes the minus sign from a specified numeric argument and returns the absolute value (integer, float, or double) of the same type as the argument to the function, which is always a positive number or zero.
13	ALL=<ul><li>An <b>ALL</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for all values in the result of the subquery or the result of the subquery is empty.</li><li>An <b>ALL</b> conditional expression is <code>false</code> if the result of the comparison is <code>false</code> for at least one row, and is unknown if neither <code>true</code> nor <code>false</code>.</ul><p><p>The comparison operators used with <b>ALL</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
14	#AND
15	ANY=<ul><li>An <b>ANY</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for some value in the result of the subquery.</li><li>An <b>ANY</b> conditional expression is <code>false</code> if the result of the subquery is empty or if the comparison operation is <code>false</code> for every value in the result of the subquery,</li><li>and is unknown if neither <code>true</code> nor <code>false</code>.</li></ul><p><p>The comparison operators used with <b>ANY</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
16	ASC=The keyword <b>ASC</b> specifies that ascending ordering be used for the associated order by item.
17	AVG=One of the aggregate functions. The arguments must be numeric. <b>AVG</b> returns <code>Double</code>.<p><p><b>BNF:</b> <code>expression ::= AVG([DISTINCT] state_field_path_expression)</code>
18	BETWEEN=Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values. Numeric, string and date expression can be evaluated in this way.
19	BOTH=Trim from both ends.
20	CONCAT=The <b>CONCAT</b> function returns a string that is a concatenation of its arguments.
21	COUNT=One of the aggregate functions. The return type of this function is a <code>Long</code>.
22	CURRENT_DATE=This function returns the value of current date on the database server.
23	CURRENT_TIME=This function returns the value of current time on the database server.
24	CURRENT_TIMESTAMP=This function returns the value of current timestamp on the database
25	DELETE_FROM=A delete statement provide bulk operations over sets of entities.
26	DESC=The keyword <b>DESC</b> specifies that descending ordering be used. Ascending ordering is the default.
27	DISTINCT=The <b>DISTINCT</b> keyword is used to specify that duplicate values must be eliminated from the query result. If <b>DISTINCT</b> is not specified, duplicate values are not eliminated.
28	ESCAPE=The optional <code>escape character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character) and is used to escape the special meaning of the underscore and percent characters in <code>pattern value</code>.
29	EXISTS=An <b>EXISTS</b> expression is a predicate that is <code>true</code> only if the result of the subquery consists of one or more values and that is <code>false</code> otherwise.
30	FROM=The <b>FROM</b> clause of a query defines the domain of the query by declaring identification variables. An identification variable is an identifier declared in the <b>FROM</b> clause of a query. The domain of the query may be constrained by path expressions. Identification variables designate instances of a particular entity abstract schema type. The <b>FROM</b> clause can contain multiple identification variable declarations separated by a comma (,).
31	GROUP_BY=The <b>GROUP BY</b> construct enables the aggregation of values according to the properties of an entity class.
32	HAVING=The <b>HAVING</b> construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
33	IN=An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression. Such a path expression represents a navigation involving the association-fields of an entity abstract schema type. Because a path expression can be based on another path expression, the navigation can use the association-fields of related entities. An identification variable of a collection member declaration is declared using a special operator, the reserved identifier <b>IN</b>. The argument to the <b>IN</b> operator is a collection-valued path expression. The path expression evaluates to a collection type specified as a result of navigation to a collection-valued association-field of an entity abstract schema type.
34	IS_EMPTY=An <b>EMPTY</b> expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
35	IS_NULL=A null comparison tests whether or not the single-valued path expression or input parameter is a <b>NULL</b> value.
36	JOIN=A <b>JOIN</b> enables the fetching of an association as a side effect of the execution of a query. A <b>JOIN</b> is specified over an entity and its related entities.
37	JOIN_FETCH=A <b>JOIN FETCH</b> enables the fetching of an association as a side effect of the execution of a query. A <b>JOIN FETCH</b> is specified over an entity and its related entities.
38	LEADING=Trim from leading end.
39	LENGTH=The <b>LENGTH</b> function returns the length of the string in characters as an integer.
40	LIKE=The <b>LIKE</b> condition is used to specify a search for a pattern.<p><p>The <code>string_expression</code> must have a string value. The <code>pattern_value</code> is a string literal or a string-valued input parameter in which an underscore (_) stands for any single character, a percent (%) character stands for any sequence of characters (including the empty sequence), and all other characters stand for themselves. The optional <code>escape_character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character) and is used to escape the special meaning of the underscore and percent characters in <code>pattern_value</code>.
41	LOCATE=The <b>LOCATE</b> function returns the position of a given string within a string, starting the search at a specified position. It returns the first position at which the string was found as an integer. The first argument is the string to be located; the second argument is the string to be searched; the optional third argument is an integer that represents the string position at which the search is started (by default, the beginning of the string to be searched). The first position in a string is denoted by 1. If the string is not found, 0 is returned. The <b>LENGTH</b> function returns the length of the string in characters as an integer.
42	LOWER=The <b>LOWER</b> function converts a string to lower case and it returns a string.
43	MAX=One of the aggregate functions. The arguments must correspond to orderable state-field types (i.e., numeric types, string types, character types, or date types). The return type of this function is based on the state-field's type.
44	MEMBER=This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression. If the collection-valued path expression designates an empty collection, the value of the <b>MEMBER OF</b> expression is <b>FALSE</b> and the value of the <b>NOT MEMBER OF</b> expression is <b>TRUE</b>. Otherwise, if the value of the collection-valued path expression or single-valued association-field path expression in the collection member expression is <b>NULL</b> or unknown, the value of the collection member expression is unknown.
45	MIN= One of the aggregate functions. The arguments must correspond to orderable state-field types (i.e., numeric types, string types, character types, or date types). The return type of this function is based on the state-field's type.
46	MOD=The modulo operation finds the remainder of division of one number by another. It takes two integer arguments and returns an integer.
47	NEW=In the <b>SELECT</b> clause a constructor may be used in the <b>SELECT</b> list to return one or more Java instances. The specified class is not required to be an entity or to be mapped to the database. The constructor name must be fully qualified.
48	OBJECT=Stand-alone identification variables in the <b>SELECT</b> clause may optionally be qualified by the <b>OBJECT</b> operator. The <b>SELECT</b> clause must not use the <b>OBJECT</b> operator to qualify path expressions.
49	#OR
50	ORDER_BY=The <b>ORDER BY</b> clause allows the objects or values that are returned by the query to be ordered.
51	SELECT=The <b>SELECT</b> clause determines the type of the objects or values to be selected.
52	SIZE=The <b>SIZE</b> function returns an integer value, the number of elements of the collection. If the collection is empty, the <b>SIZE</b> function evaluates to zero.
53	SOME=<ul><li>An <b>SOME</b> conditional expression is a predicate that is <code>true</code> if the comparison operation is <code>true</code> for some value in the result of the subquery.</li><li>A <b>SOME</b> conditional expression is <code>false</code> if the result of the subquery is empty or if the comparison operation is <code>false</code> for every value in the result of the subquery,</li><li>and is unknown if neither <code>true</code> nor <code>false</code>.</li></ul><p><p>The comparison operators used with <b>SOME</b> conditional expressions are =, <, <=, >, >=, <>.<p><p>The result of the subquery must be like that of the other argument to the comparison operator in type.
54	SQRT=The <b>SQRT</b> function takes a numeric argument and returns a double.
55	SUBSTRING=The second and third arguments of the <b>SUBSTRING</b> function denote the starting position and length of the substring to be returned. These arguments are integers. The first position of a string is denoted by 1. The <b>SUBSTRING</b> function returns a string.
56	SUM= One of the aggregate functions. The arguments must be numeric. The <b>SUM</b> function returns <code>Long</code> when applied to state-fields of integral types (other than <code>BigInteger</code>); <code>Double</code> when applied to state-fields of floating point types; <code>BigInteger</code> when applied to state-fields of type <code>BigInteger</code>; and <code>BigDecimal</code> when applied to state-fields of type <code>BigDecimal</code>. If <b>SUM</b>, <b>AVG</b>, <b>MAX</b>, or <b>MIN</b> is used, and there are no values to which the aggregate function can be applied, the result of the aggregate function is <code>NULL</code>. If <code>COUNT</code> is used, and there are no values to which <b>COUNT</b> can be applied, the result of the aggregate function is 0.
57	TRAILING=Trim from trailing end.
58	TRIM=The <b>TRIM</b> function trims the specified character from a string. If the character to be trimmed is not specified, it is assumed to be space (or blank). The optional <code>trim_character</code> is a single-character string literal or a character-valued input parameter (i.e., char or Character). If a trim specification is not provided, <b>BOTH</b> is assumed. The <b>TRIM</b> function returns the trimmed string.
59	UPDATE=An update statement provide bulk operations over sets of entities.
60	UPPER=The <b>UPPER</b> function converts a string to upper case and it returns a string.
61	WHERE=The <b>WHERE</b> clause of a query consists of a conditional expression used to select objects or values that satisfy the expression. The <b>WHERE</b> clause restricts the result of a select statement or the scope of an update or delete operation.
62
63	# JPA 2.0 identifiers
64	#CASE=
65	COALESCE=A <b>COALESCE</b> expression returns <code>null</code> if all its arguments evaluate to <code>null</code>, and the value of the first non-<code>null</code> argument otherwise.<p><p>The return type is the type returned by the arguments if they are all of the same type, otherwise it is undetermined.
66	#ENTRY=
67	INDEX=The <b>INDEX</b> function returns an integer value corresponding to the position of its argument in an ordered list. The <b>INDEX</b> function can only be applied to identification variables denoting types for which an order column has been specified.
68	#KEY=
69	NULLIF=<b>NULLIF</b> returns the first expression if the two expressions are not equal. If the expressions are equal, <b>NULLIF</b> returns a null value of the type of the first expression.<p><p><b>NULLIF</b> is equivalent to a searched <b>CASE</b> expression in which the two expressions are equal and the resulting expression is <b>NULL</b>.<p><p>Returns the same type as the first expression.
70	TYPE=An entity type expression can be used to restrict query polymorphism. The <b>TYPE</b> operator returns the exact type of the argument.
71	#VALUE=
72
73	# EclipseLink identifiers
74	#FUNC=
75	#TREAT=
76
77	# Reserved JPQL identifiers
78	BIT_LENGTH=The identifier <b>BIT_LENGTH</b> is not currently used: it is reserved for future use.
79	CHAR_LENGTH=The identifier <b>CHAR_LENGTH</b> is not currently used: it is reserved for future use.
80	CHARACTER_LENGTH=The identifier <b>CHARACTER_LENGTH</b> is not currently used: it is reserved for future use.
81	CLASS=The identifier <b>CLASS</b> is not currently used: it is reserved for future use.
82	POSITION=The identifier <b>POSITION</b> is not currently used: it is reserved for future use.
83	UNKNOWN=The identifier <b>UNKNOWN</b> is not currently used: it is reserved for future use.

Lines 124-127 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/JptUiIcons.java (-1 / +10 lines)
124	public static final String TRANSIENT = "full/obj16/transient";	124	public static final String TRANSIENT = "full/obj16/transient";
125		125
126	public static final String NULL_ATTRIBUTE_MAPPING = "full/obj16/null-attribute-mapping";	126	public static final String NULL_ATTRIBUTE_MAPPING = "full/obj16/null-attribute-mapping";
127	}	127
		128
		129	// ************** Content Assist icons ********************************
		130
		131	public static final String JPQL_FUNCTION = "full/obj16/jpql.function";
		132
		133	public static final String JPQL_IDENTIFIER = "full/obj16/jpql.identifier";
		134
		135	public static final String JPQL_VARIABLE = "full/obj16/jpql.variable";
		136	}

Lines 92-97 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/JptUiMessages.java (-1 / +4 lines)
92	public static String JpaFacetWizardPage_title;	92	public static String JpaFacetWizardPage_title;
93	public static String JpaFacetWizardPage_userLibsLink;	93	public static String JpaFacetWizardPage_userLibsLink;
94	public static String JpaFacetWizardPage_userServerLibLabel;	94	public static String JpaFacetWizardPage_userServerLibLabel;
		95	public static String JpaJpqlJavaCompletionProposalComputer_Error;
		96	public static String JpaJpqlSseCompletionProposalComputer_Error;
95	public static String JpaLibraryProviderInstallPanel_includeLibraries;	97	public static String JpaLibraryProviderInstallPanel_includeLibraries;
96	public static String JpaMakePersistentWizardPage_title;	98	public static String JpaMakePersistentWizardPage_title;
97	public static String JpaMakePersistentWizardPage_message;	99	public static String JpaMakePersistentWizardPage_message;
Lines 110-115 Link Here
110	public static String JpaStructureView_linkWithEditorTooltip;	112	public static String JpaStructureView_linkWithEditorTooltip;
111	public static String JpaStructureView_structureNotAvailable;	113	public static String JpaStructureView_structureNotAvailable;
112	public static String JpaStructureView_numItemsSelected;	114	public static String JpaStructureView_numItemsSelected;
		115	public static String JpqlContentProposalProvider_Description;
113	public static String MappingFileWizard_title;	116	public static String MappingFileWizard_title;
114	public static String MappingFileWizardPage_newFile_title;	117	public static String MappingFileWizardPage_newFile_title;
115	public static String MappingFileWizardPage_newFile_desc;	118	public static String MappingFileWizardPage_newFile_desc;
Lines 140-146 Link Here
140	public static String JpaProblemSeveritiesPage_Warning;	143	public static String JpaProblemSeveritiesPage_Warning;
141	public static String SelectJpaOrmMappingFileDialog_newButton;	144	public static String SelectJpaOrmMappingFileDialog_newButton;
142		145
143		146
144	private static final String BUNDLE_NAME = "jpt_ui"; //$NON-NLS-1$	147	private static final String BUNDLE_NAME = "jpt_ui"; //$NON-NLS-1$
145	private static final Class<?> BUNDLE_CLASS = JptUiMessages.class;	148	private static final Class<?> BUNDLE_CLASS = JptUiMessages.class;
146	static {	149	static {

Lines 17-24 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/details/QueriesComposite.java (-3 / +3 lines)
17	import org.eclipse.jface.window.Window;	17	import org.eclipse.jface.window.Window;
18	import org.eclipse.jpt.common.ui.internal.util.ControlSwitcher;	18	import org.eclipse.jpt.common.ui.internal.util.ControlSwitcher;
19	import org.eclipse.jpt.common.ui.internal.widgets.AddRemoveListPane;	19	import org.eclipse.jpt.common.ui.internal.widgets.AddRemoveListPane;
20	import org.eclipse.jpt.common.ui.internal.widgets.Pane;
21	import org.eclipse.jpt.common.ui.internal.widgets.AddRemovePane.Adapter;	20	import org.eclipse.jpt.common.ui.internal.widgets.AddRemovePane.Adapter;
		21	import org.eclipse.jpt.common.ui.internal.widgets.Pane;
22	import org.eclipse.jpt.common.utility.internal.CollectionTools;	22	import org.eclipse.jpt.common.utility.internal.CollectionTools;
23	import org.eclipse.jpt.common.utility.internal.Transformer;	23	import org.eclipse.jpt.common.utility.internal.Transformer;
24	import org.eclipse.jpt.common.utility.internal.model.value.CompositeListValueModel;	24	import org.eclipse.jpt.common.utility.internal.model.value.CompositeListValueModel;
Lines 75-81 Link Here
75	{	75	{
76	private AddRemoveListPane<QueryContainer> listPane;	76	private AddRemoveListPane<QueryContainer> listPane;
77	NamedNativeQueryPropertyComposite namedNativeQueryPane;	77	NamedNativeQueryPropertyComposite namedNativeQueryPane;
78	NamedQueryPropertyComposite<? extends NamedQuery> namedQueryPane;	78	Pane<? extends NamedQuery> namedQueryPane;
79	private WritablePropertyValueModel<Query> queryHolder;	79	private WritablePropertyValueModel<Query> queryHolder;
80		80
81		81
Lines 295-301 Link Here
295	installPaneSwitcher(pageBook);	295	installPaneSwitcher(pageBook);
296	}	296	}
297		297
298	protected NamedQueryPropertyComposite<? extends NamedQuery> buildNamedQueryPropertyComposite(PageBook pageBook) {	298	protected Pane<? extends NamedQuery> buildNamedQueryPropertyComposite(PageBook pageBook) {
299	return new NamedQueryPropertyComposite<NamedQuery>(	299	return new NamedQueryPropertyComposite<NamedQuery>(
300	this,	300	this,
301	this.buildNamedQueryHolder(),	301	this.buildNamedQueryHolder(),

Lines 73-85 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/preferences/JpaProblemSeveritiesPage.java (-21 / +22 lines)
73		73
74	/**	74	/**
75	* Default severity levels are stored here, ERROR is the default default so only need	75	* Default severity levels are stored here, ERROR is the default default so only need
76	* to include WARNING, INFO, IGNORE in this Map. These will be displayed if neither the project	76	* to include WARNING, INFO, IGNORE in this Map. These will be displayed if neither the project
77	* or workspace preference applies.	77	* or workspace preference applies.
78	* <br> key is the preferenceKey which is also the validation message key @see JpaValidationMessages.	78	* <br> key is the preferenceKey which is also the validation message key @see JpaValidationMessages.
79	* <br> value is a severity level - @see JpaValidationPreferences#ERROR WARNING INFO IGNORE	79	* <br> value is a severity level - @see JpaValidationPreferences#ERROR WARNING INFO IGNORE
80	*/	80	*/
81	private Map<String, String> defaultSeverities;	81	private Map<String, String> defaultSeverities;
82		82
83	/**	83	/**
84	* The list of <code>Combo</code>s is cached in order to perform a revert of	84	* The list of <code>Combo</code>s is cached in order to perform a revert of
85	* the properties.	85	* the properties.
Lines 335-341 Link Here
335	private void addAttributeLevelCategory(Composite parent) {	335	private void addAttributeLevelCategory(Composite parent) {
336		336
337	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.ATTRIBUTE_LEVEL_CATEGORY);	337	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.ATTRIBUTE_LEVEL_CATEGORY);
338		338
339	addLabeledCombo(	339	addLabeledCombo(
340	parent, JptUiValidationPreferenceMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME,	340	parent, JptUiValidationPreferenceMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME,
341	JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME);	341	JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME);
Lines 395-401 Link Here
395	JpaValidationMessages.ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);	395	JpaValidationMessages.ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);
396		396
397	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);	397	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);
398		398
399	addLabeledCombo(	399	addLabeledCombo(
400	parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY,	400	parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY,
401	JpaValidationMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY);	401	JpaValidationMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY);
Lines 410-416 Link Here
410	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);	410	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);
411	addLabeledCombo(	411	addLabeledCombo(
412	parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED,	412	parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED,
413	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);	413	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED);
414	}	414	}
415		415
416	private void addDatabaseCategory(Composite parent) {	416	private void addDatabaseCategory(Composite parent) {
Lines 423-431 Link Here
423	}	423	}
424		424
425	private void addTableCategory(Composite parent) {	425	private void addTableCategory(Composite parent) {
426		426
427	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.TABLE_CATEGORY);	427	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.TABLE_CATEGORY);
428		428
429	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_CATALOG, JpaValidationMessages.TABLE_UNRESOLVED_CATALOG);	429	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_CATALOG, JpaValidationMessages.TABLE_UNRESOLVED_CATALOG);
430	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_SCHEMA, JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA);	430	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_SCHEMA, JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA);
431	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_NAME, JpaValidationMessages.TABLE_UNRESOLVED_NAME);	431	addLabeledCombo(parent, JptUiValidationPreferenceMessages.TABLE_UNRESOLVED_NAME, JpaValidationMessages.TABLE_UNRESOLVED_NAME);
Lines 452-461 Link Here
452	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA, JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA);	452	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA, JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_SCHEMA);
453	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME, JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME);	453	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME, JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLLECTION_TABLE_UNRESOLVED_NAME);
454	}	454	}
455		455
456	private void addColumnCategory(Composite parent) {	456	private void addColumnCategory(Composite parent) {
457	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.COLUMN_CATEGORY);	457	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.COLUMN_CATEGORY);
458		458
459	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_TABLE_NOT_VALID, JpaValidationMessages.COLUMN_TABLE_NOT_VALID);	459	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_TABLE_NOT_VALID, JpaValidationMessages.COLUMN_TABLE_NOT_VALID);
460	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_TABLE, JpaValidationMessages.COLUMN_UNRESOLVED_TABLE);	460	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_TABLE, JpaValidationMessages.COLUMN_UNRESOLVED_TABLE);
461	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_NAME, JpaValidationMessages.COLUMN_UNRESOLVED_NAME);	461	addLabeledCombo(parent, JptUiValidationPreferenceMessages.COLUMN_UNRESOLVED_NAME, JpaValidationMessages.COLUMN_UNRESOLVED_NAME);
Lines 503-509 Link Here
503	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID, JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID);	503	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID, JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID);
504	}	504	}
505		505
506	private void addOverridesCategory(Composite parent) {	506	private void addOverridesCategory(Composite parent) {
507		507
508	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.OVERRIDES_CATEGORY);	508	parent = addExpandableSection(parent, JptUiValidationPreferenceMessages.OVERRIDES_CATEGORY);
509		509
Lines 529-535 Link Here
529	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);	529	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);
530	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);	530	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS, JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_INVERSE_JOIN_COLUMNS);
531		531
532		532
533	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);	533	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);
534		534
535	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME);	535	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_INVALID_NAME);
Lines 591-602 Link Here
591	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME, JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME);	591	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME, JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME);
592	addLabeledCombo(parent, JptUiValidationPreferenceMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR, JpaValidationMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR);	592	addLabeledCombo(parent, JptUiValidationPreferenceMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR, JpaValidationMessages.GENERATED_VALUE_UNRESOLVED_GENERATOR);
593	addLabeledCombo(parent, JptUiValidationPreferenceMessages.QUERY_DUPLICATE_NAME, JpaValidationMessages.QUERY_DUPLICATE_NAME);	593	addLabeledCombo(parent, JptUiValidationPreferenceMessages.QUERY_DUPLICATE_NAME, JpaValidationMessages.QUERY_DUPLICATE_NAME);
		594	addLabeledCombo(parent, JptUiValidationPreferenceMessages.JPQL_QUERY_VALIDATION, JpaValidationMessages.JPQL_QUERY_VALIDATION);
594	}	595	}
595		596
596	private Composite addExpandableSection(Composite parent, String text) {	597	private Composite addExpandableSection(Composite parent, String text) {
597	return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false));	598	return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false));
598	}	599	}
599		600
600	private Composite addSubExpandableSection(Composite parent, String text) {	601	private Composite addSubExpandableSection(Composite parent, String text) {
601	return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false, 2, 1));	602	return addExpandableSection(parent, text, new GridData(GridData.FILL, GridData.FILL, true, false, 2, 1));
602	}	603	}
Lines 714-720 Link Here
714	String preference = this.defaultSeverities.get(preferenceKey);	715	String preference = this.defaultSeverities.get(preferenceKey);
715	return preference == null ? JpaValidationPreferences.ERROR : preference;	716	return preference == null ? JpaValidationPreferences.ERROR : preference;
716	}	717	}
717		718
718	protected int convertPreferenceValueToComboIndex(String preferenceValue) {	719	protected int convertPreferenceValueToComboIndex(String preferenceValue) {
719	if (JpaValidationPreferences.ERROR.equals(preferenceValue)) {	720	if (JpaValidationPreferences.ERROR.equals(preferenceValue)) {
720	return ERROR_INDEX;	721	return ERROR_INDEX;
Lines 778-784 Link Here
778	revertToDefault();	779	revertToDefault();
779	}	780	}
780	}	781	}
781		782
782	@Override	783	@Override
783	protected void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {	784	protected void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {
784	super.enableProjectSpecificSettings(useProjectSpecificSettings);	785	super.enableProjectSpecificSettings(useProjectSpecificSettings);
Lines 787-795 Link Here
787	// "otherwise the 'enable project specific settings' checkbox is being pressed")	788	// "otherwise the 'enable project specific settings' checkbox is being pressed")
788	return;	789	return;
789	}	790	}
790		791
791	this.hasProjectSpecificPreferences = Boolean.valueOf(useProjectSpecificSettings);	792	this.hasProjectSpecificPreferences = Boolean.valueOf(useProjectSpecificSettings);
792		793
793	//set all specified workspace preferences in the project preferences	794	//set all specified workspace preferences in the project preferences
794	if (useProjectSpecificSettings){	795	if (useProjectSpecificSettings){
795	this.overrideWorkspacePreferences();	796	this.overrideWorkspacePreferences();
Lines 812-818 Link Here
812	preference = getDefaultPreferenceValue(preferenceKey);	813	preference = getDefaultPreferenceValue(preferenceKey);
813	}	814	}
814	combo.select(convertPreferenceValueToComboIndex(preference));	815	combo.select(convertPreferenceValueToComboIndex(preference));
815	//UI will show the defaults from the workspace, but set all preferences	816	//UI will show the defaults from the workspace, but set all preferences
816	//to null so they will be deleted from project preferences	817	//to null so they will be deleted from project preferences
817	this.severityLevels.put(preferenceKey, null);	818	this.severityLevels.put(preferenceKey, null);
818	}	819	}
Lines 833-839 Link Here
833	}	834	}
834	}	835	}
835	}	836	}
836		837
837	// ******** OK/Revert/Apply behavior ********	838	// ******** OK/Revert/Apply behavior ********
838		839
839	@Override	840	@Override
Lines 858-864 Link Here
858	}	859	}
859	catch (InterruptedException ex) {	860	catch (InterruptedException ex) {
860	return false;	861	return false;
861	}	862	}
862	catch (InvocationTargetException ex) {	863	catch (InvocationTargetException ex) {
863	throw new RuntimeException(ex.getTargetException());	864	throw new RuntimeException(ex.getTargetException());
864	}	865	}