Attachment #226593 for bug #392701




public interface NamedNativeQuery
	extends Query
{

	// ********** query **********

	String QUERY_PROPERTY = "query"; //$NON-NLS-1$

	String getQuery();

	void setQuery(String query);


	// ********** result class **********

	String getResultClass();

Lines 24-28 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/NamedQuery.java (-1 / +10 lines)
24	public interface NamedQuery	24	public interface NamedQuery
25	extends Query	25	extends Query
26	{	26	{
27	// nothing yet	27
		28	// ******** query ********
		29
		30	String QUERY_PROPERTY = "query"; //$NON-NLS-1$
		31
		32	String getQuery();
		33
		34	void setQuery(String query);
		35
		36
28	}	37	}




			NamedNativeQuery.class
		);

	// ********** query **********

	String QUERY_PROPERTY = "query"; //$NON-NLS-1$

	String getQuery();

	void setQuery(String query);


	// ********** hints **********

	String HINTS_LIST = "hints"; //$NON-NLS-1$





	protected String name;

	protected String query;

	protected final ContextListContainer<JavaQueryHint, QueryHintAnnotation> hintContainer;



		super(parent);
		this.queryAnnotation = queryAnnotation;
		this.name = queryAnnotation.getName();
		this.query = queryAnnotation.getQuery();
		this.hintContainer = this.buildHintContainer();
	}


	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.setName_(this.queryAnnotation.getName());
		this.setQuery_(this.queryAnnotation.getQuery());
		this.syncHints();
	}


		String old = this.name;
		this.name = name;
		this.firePropertyChanged(NAME_PROPERTY, old, name);
	}


	// ********** query **********

	public String getQuery() {
		return this.query;
	}

	public void setQuery(String query) {
		this.queryAnnotation.setQuery(query);
		this.setQuery_(query);
	}

	protected void setQuery_(String query) {
		String old = this.query;
		this.query = query;
		this.firePropertyChanged(QUERY_PROPERTY, old, query);
	}



	public void validate(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		super.validate(messages, reporter);
		this.validateName(messages);
		this.validateQuery(queryHelper, messages, reporter);
	}

	protected void validateName(List<IMessage> messages) {

		}
	}

	public void validateQuery(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		if (StringTools.isBlank(this.query)){
			messages.add(
				DefaultJpaValidationMessages.buildMessage(
					IMessage.HIGH_SEVERITY,
					JpaValidationMessages.QUERY_STATEMENT_UNDEFINED,
					new String[] {this.name},
					this,
					this.getNameTextRange()
				)
			);
		} else {
			this.validateQuery_(queryHelper, messages, reporter);
		}
	}

	protected abstract void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter);

	public TextRange getValidationTextRange() {
		TextRange textRange = this.queryAnnotation.getTextRange();
		return (textRange != null) ? textRange : this.getParent().getValidationTextRange();


	public TextRange getNameTextRange() {
		return this.getValidationTextRange(this.queryAnnotation.getNameTextRange());
	}

	public List<TextRange> getQueryTextRanges() {
		return this.queryAnnotation.getQueryTextRanges();
	}

	public boolean isEquivalentTo(JpaNamedContextNode node) {


	protected boolean isEquivalentTo(Query other) {
		return ObjectTools.equals(this.name, other.getName()) &&
				ObjectTools.equals(this.query, other.getQuery()) &&
				this.hintsAreEquivalentTo(other);
	}


Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaNamedNativeQuery.java (-3 / +54 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2012 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2013 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-22 Link Here
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;	12	import java.util.List;
		13	import org.eclipse.jpt.common.core.utility.TextRange;
13	import org.eclipse.jpt.common.utility.internal.ObjectTools;	14	import org.eclipse.jpt.common.utility.internal.ObjectTools;
		15	import org.eclipse.jpt.common.utility.internal.StringTools;
14	import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;	16	import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;
15	import org.eclipse.jpt.jpa.core.context.Query;	17	import org.eclipse.jpt.jpa.core.context.Query;
16	import org.eclipse.jpt.jpa.core.context.java.JavaNamedNativeQuery;	18	import org.eclipse.jpt.jpa.core.context.java.JavaNamedNativeQuery;
17	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;	19	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;
18	import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;	20	import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;
19	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;	21	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;
		22	import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
		23	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
20	import org.eclipse.jpt.jpa.core.jpql.JpaJpqlQueryHelper;	24	import org.eclipse.jpt.jpa.core.jpql.JpaJpqlQueryHelper;
21	import org.eclipse.jpt.jpa.core.resource.java.NamedNativeQueryAnnotation;	25	import org.eclipse.jpt.jpa.core.resource.java.NamedNativeQueryAnnotation;
22	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	26	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
Lines 29-34 Link Here
29	extends AbstractJavaQuery<NamedNativeQueryAnnotation>	33	extends AbstractJavaQuery<NamedNativeQueryAnnotation>
30	implements JavaNamedNativeQuery	34	implements JavaNamedNativeQuery
31	{	35	{
		36	protected String query;
		37
32	protected String resultClass;	38	protected String resultClass;
33	protected String fullyQualifiedResultClass;	39	protected String fullyQualifiedResultClass;
34		40
Lines 37-42 Link Here
37		43
38	public GenericJavaNamedNativeQuery(JavaQueryContainer parent, NamedNativeQueryAnnotation queryAnnotation) {	44	public GenericJavaNamedNativeQuery(JavaQueryContainer parent, NamedNativeQueryAnnotation queryAnnotation) {
39	super(parent, queryAnnotation);	45	super(parent, queryAnnotation);
		46	this.query = queryAnnotation.getQuery();
40	this.resultClass = queryAnnotation.getResultClass();	47	this.resultClass = queryAnnotation.getResultClass();
41	this.resultSetMapping = queryAnnotation.getResultSetMapping();	48	this.resultSetMapping = queryAnnotation.getResultSetMapping();
42	}	49	}
Lines 47-52 Link Here
47	@Override	54	@Override
48	public void synchronizeWithResourceModel() {	55	public void synchronizeWithResourceModel() {
49	super.synchronizeWithResourceModel();	56	super.synchronizeWithResourceModel();
		57	this.setQuery_(this.queryAnnotation.getQuery());
50	this.setResultClass_(this.queryAnnotation.getResultClass());	58	this.setResultClass_(this.queryAnnotation.getResultClass());
51	this.setResultSetMapping_(this.queryAnnotation.getResultSetMapping());	59	this.setResultSetMapping_(this.queryAnnotation.getResultSetMapping());
52	}	60	}
Lines 56-61 Link Here
56	super.update();	64	super.update();
57	this.setFullyQualifiedResultClass(this.buildFullyQualifiedResultClass());	65	this.setFullyQualifiedResultClass(this.buildFullyQualifiedResultClass());
58	}	66	}
		67
		68	// ******** query ********
		69
		70	public String getQuery() {
		71	return this.query;
		72	}
		73
		74	public void setQuery(String query) {
		75	this.queryAnnotation.setQuery(query);
		76	this.setQuery_(query);
		77	}
		78
		79	protected void setQuery_(String query) {
		80	String old = this.query;
		81	this.query = query;
		82	this.firePropertyChanged(QUERY_PROPERTY, old, query);
		83	}
		84
59		85
60	// ******** result class ********	86	// ******** result class ********
61		87
Lines 122-130 Link Here
122		148
123	// ******** validation ********	149	// ******** validation ********
124		150
125	@Override	151	public void validate(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		152	super.validate(messages, reporter);
		153	this.validateQuery(queryHelper, messages, reporter);
		154	}
		155
		156	public void validateQuery(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		157	if (StringTools.isBlank(this.query)){
		158	messages.add(
		159	DefaultJpaValidationMessages.buildMessage(
		160	IMessage.HIGH_SEVERITY,
		161	JpaValidationMessages.QUERY_STATEMENT_UNDEFINED,
		162	new String[] {this.name},
		163	this,
		164	this.getNameTextRange()
		165	)
		166	);
		167	} else {
		168	this.validateQuery_(queryHelper, messages, reporter);
		169	}
		170	}
		171
126	protected void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {	172	protected void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
127	// nothing yet	173	// nothing yet
		174	}
		175
		176	public List<TextRange> getQueryTextRanges() {
		177	return this.queryAnnotation.getQueryTextRanges();
128	}	178	}
129		179
130	@Override	180	@Override
Lines 134-140 Link Here
134	}	184	}
135		185
136	protected boolean isEquivalentTo(NamedNativeQuery other) {	186	protected boolean isEquivalentTo(NamedNativeQuery other) {
137	return ObjectTools.equals(this.resultClass, other.getResultClass()) &&	187	return ObjectTools.equals(this.query, other.getQuery()) &&
		188	ObjectTools.equals(this.resultClass, other.getResultClass()) &&
138	ObjectTools.equals(this.resultSetMapping, other.getResultSetMapping());	189	ObjectTools.equals(this.resultSetMapping, other.getResultSetMapping());
139	}	190	}
140		191

Lines 10-20 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaNamedQuery.java (-12 / +73 lines)
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;	12	import java.util.List;
		13	import org.eclipse.jpt.common.core.utility.TextRange;
		14	import org.eclipse.jpt.common.utility.internal.ObjectTools;
		15	import org.eclipse.jpt.common.utility.internal.StringTools;
		16	import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;
13	import org.eclipse.jpt.jpa.core.context.NamedQuery;	17	import org.eclipse.jpt.jpa.core.context.NamedQuery;
14	import org.eclipse.jpt.jpa.core.context.Query;	18	import org.eclipse.jpt.jpa.core.context.Query;
15	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;	19	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;
16	import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;	20	import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;
17	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;	21	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;
		22	import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
		23	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
18	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;	24	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;
19	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;	25	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;
20	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaNamedQuery2_0;	26	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaNamedQuery2_0;
Lines 31-42 Link Here
31	extends AbstractJavaQuery<NamedQueryAnnotation>	37	extends AbstractJavaQuery<NamedQueryAnnotation>
32	implements JavaNamedQuery2_0	38	implements JavaNamedQuery2_0
33	{	39	{
		40	protected String query;
		41
34	protected LockModeType2_0 specifiedLockMode;	42	protected LockModeType2_0 specifiedLockMode;
35	protected LockModeType2_0 defaultLockMode;	43	protected LockModeType2_0 defaultLockMode;
36		44
37	public GenericJavaNamedQuery(JavaQueryContainer parent, NamedQueryAnnotation queryAnnotation) {	45	public GenericJavaNamedQuery(JavaQueryContainer parent, NamedQueryAnnotation queryAnnotation) {
38	super(parent, queryAnnotation);	46	super(parent, queryAnnotation);
39	this.specifiedLockMode = this.buildSpecifiedLockMode();	47	this.specifiedLockMode = this.buildSpecifiedLockMode();
		48	this.query = queryAnnotation.getQuery();
40	}	49	}
41		50
42	// ******** synchronize/update ********	51	// ******** synchronize/update ********
Lines 44-49 Link Here
44	@Override	53	@Override
45	public void synchronizeWithResourceModel() {	54	public void synchronizeWithResourceModel() {
46	super.synchronizeWithResourceModel();	55	super.synchronizeWithResourceModel();
		56	this.setQuery_(this.queryAnnotation.getQuery());
47	this.setSpecifiedLockMode_(this.buildSpecifiedLockMode());	57	this.setSpecifiedLockMode_(this.buildSpecifiedLockMode());
48	}	58	}
49		59
Lines 52-57 Link Here
52	super.update();	62	super.update();
53	this.setDefaultLockMode(this.buildDefaultLockMode());	63	this.setDefaultLockMode(this.buildDefaultLockMode());
54	}	64	}
		65
		66
		67	// ******** query ********
		68
		69	public String getQuery() {
		70	return this.query;
		71	}
		72
		73	public void setQuery(String query) {
		74	this.queryAnnotation.setQuery(query);
		75	this.setQuery_(query);
		76	this.query = queryAnnotation.getQuery();
		77	}
		78
		79	protected void setQuery_(String query) {
		80	String old = this.query;
		81	this.query = query;
		82	this.firePropertyChanged(QUERY_PROPERTY, old, query);
		83	}
		84
		85
55	// ******** lock mode ********	86	// ******** lock mode ********
56		87
57	public LockModeType2_0 getLockMode() {	88	public LockModeType2_0 getLockMode() {
Lines 95-101 Link Here
95	return LockModeType2_0.NONE;	126	return LockModeType2_0.NONE;
96	}	127	}
97	return null;	128	return null;
98	}	129	}
		130
99		131
100	// ******** metadata conversion *******	132	// ******** metadata conversion *******
101		133
Lines 109-125 Link Here
109		141
110	// ******** validation ********	142	// ******** validation ********
111		143
112	@Override	144	public void validate(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		145	super.validate(messages, reporter);
		146	this.validateQuery(queryHelper, messages, reporter);
		147	}
		148
		149	public void validateQuery(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
		150	if (StringTools.isBlank(this.query)){
		151	messages.add(
		152	DefaultJpaValidationMessages.buildMessage(
		153	IMessage.HIGH_SEVERITY,
		154	JpaValidationMessages.QUERY_STATEMENT_UNDEFINED,
		155	new String[] {this.name},
		156	this,
		157	this.getNameTextRange()
		158	)
		159	);
		160	} else {
		161	this.validateQuery_(queryHelper, messages, reporter);
		162	}
		163	}
		164
113	protected void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {	165	protected void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
114	queryHelper.validate(	166	queryHelper.validate(
115	this,	167	this,
116	this.query,	168	this.query,
117	this.query,	169	this.query,
118	this.queryAnnotation.getQueryTextRanges(),	170	this.queryAnnotation.getQueryTextRanges(),
119	1,	171	1,
120	JpaJpqlQueryHelper.EscapeType.JAVA,	172	JpaJpqlQueryHelper.EscapeType.JAVA,
121	messages	173	messages
122	);	174	);
		175	}
		176
		177	public List<TextRange> getQueryTextRanges() {
		178	return this.queryAnnotation.getQueryTextRanges();
		179	}
		180
		181	protected boolean isEquivalentTo(NamedNativeQuery other) {
		182	return ObjectTools.equals(this.query, other.getQuery());
123	}	183	}
124		184
125	@Override	185	@Override
Lines 129-135 Link Here
129	}	189	}
130		190
131	protected boolean isEquivalentTo(NamedQuery other) {	191	protected boolean isEquivalentTo(NamedQuery other) {
132	boolean queriesEquivalent = super.isEquivalentTo(other);	192	boolean queriesEquivalent = super.isEquivalentTo(other) &&
		193	ObjectTools.equals(this.query, other.getQuery());
133	if (this.isJpa2_0Compatible()) {	194	if (this.isJpa2_0Compatible()) {
134	return queriesEquivalent && this.isEquivalentTo((NamedQuery2_0) other);	195	return queriesEquivalent && this.isEquivalentTo((NamedQuery2_0) other);
135	}	196	}
Lines 145-148 Link Here
145	public Class<NamedQuery> getType() {	206	public Class<NamedQuery> getType() {
146	return NamedQuery.class;	207	return NamedQuery.class;
147	}	208	}
148	}	209	}

Lines 33-38 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/Generic2_1JpaAnnotationDefinitionProvider.java (-1 / +7 lines)
33	import org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.SequenceGenerator2_0AnnotationDefinition;	33	import org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.SequenceGenerator2_0AnnotationDefinition;
34	import org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.StaticMetamodelAnnotationDefinition;	34	import org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.StaticMetamodelAnnotationDefinition;
35	import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.Converter2_1AnnotationDefinition;	35	import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.Converter2_1AnnotationDefinition;
		36	import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.NamedStoredProcedureQueries2_1AnnotationDefinition;
		37	import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.NamedStoredProcedureQuery2_1AnnoationDefinition;
		38	import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.StoredProcedureParameter2_1AnnotationDefinition;
36	import org.eclipse.jpt.jpa.core.internal.resource.java.AssociationOverridesAnnotationDefinition;	39	import org.eclipse.jpt.jpa.core.internal.resource.java.AssociationOverridesAnnotationDefinition;
37	import org.eclipse.jpt.jpa.core.internal.resource.java.AttributeOverrideAnnotationDefinition;	40	import org.eclipse.jpt.jpa.core.internal.resource.java.AttributeOverrideAnnotationDefinition;
38	import org.eclipse.jpt.jpa.core.internal.resource.java.AttributeOverridesAnnotationDefinition;	41	import org.eclipse.jpt.jpa.core.internal.resource.java.AttributeOverridesAnnotationDefinition;
Lines 148-154 Link Here
148	TableGeneratorAnnotationDefinition.instance(),	151	TableGeneratorAnnotationDefinition.instance(),
149	TemporalAnnotationDefinition.instance(),	152	TemporalAnnotationDefinition.instance(),
150	TransientAnnotationDefinition.instance(),	153	TransientAnnotationDefinition.instance(),
151	VersionAnnotationDefinition.instance()	154	VersionAnnotationDefinition.instance(),
		155	NamedStoredProcedureQueries2_1AnnotationDefinition.instance(),
		156	StoredProcedureParameter2_1AnnotationDefinition.instance()
152	};	157	};
153		158
154	@Override	159	@Override
Lines 165-169 Link Here
165	NamedNativeQueryAnnotationDefinition.instance(),	170	NamedNativeQueryAnnotationDefinition.instance(),
166	PrimaryKeyJoinColumnAnnotationDefinition.instance(),	171	PrimaryKeyJoinColumnAnnotationDefinition.instance(),
167	SecondaryTableAnnotationDefinition.instance(),	172	SecondaryTableAnnotationDefinition.instance(),
		173	NamedStoredProcedureQuery2_1AnnoationDefinition.instance()
168	};	174	};
169	}	175	}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryNamedAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.source.SourceNamedAnnotation;
import org.eclipse.jpt.common.core.resource.java.Annotation;
import org.eclipse.jpt.common.core.resource.java.AnnotationDefinition;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement;
import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;

/**
 * javax.persistence.NamedStoredProcedureQueries
 */
public final class NamedStoredProcedureQueries2_1AnnotationDefinition
	implements AnnotationDefinition
{
	// singleton
	private static final AnnotationDefinition INSTANCE = new NamedStoredProcedureQueries2_1AnnotationDefinition();

	/**
	 * Return the singleton.
	 */
	public static AnnotationDefinition instance() {
		return INSTANCE;
	}

	/**
	 * Ensure single instance.
	 */
	private NamedStoredProcedureQueries2_1AnnotationDefinition() {
		super();
	}

	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, AnnotatedElement annotatedElement) {
		return new SourceNamedAnnotation(parent, annotatedElement, getAnnotationName());
	}

	public Annotation buildNullAnnotation(JavaResourceAnnotatedElement parent) {
		throw new UnsupportedOperationException();
	}

	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, IAnnotation jdtAnnotation) {
		return new BinaryNamedAnnotation(parent, jdtAnnotation, getAnnotationName());
	}

	public String getAnnotationName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERIES;
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotationDefinition;
import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.binary.BinaryNamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java.source.SourceNamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;

/**
 * javax.persistence.NamedStoredProcedureQuery
 */
public final class NamedStoredProcedureQuery2_1AnnoationDefinition
	implements NestableAnnotationDefinition
{
	// singleton
	private static final NestableAnnotationDefinition INSTANCE = new NamedStoredProcedureQuery2_1AnnoationDefinition();

	/**
	 * Return the singleton.
	 */
	public static NestableAnnotationDefinition instance() {
		return INSTANCE;
	}

	/**
	 * Ensure single instance.
	 */
	private NamedStoredProcedureQuery2_1AnnoationDefinition() {
		super();
	}

	public NestableAnnotation buildAnnotation(JavaResourceAnnotatedElement parent, AnnotatedElement annotatedElement, int index) {
		return SourceNamedStoredProcedureQuery2_1Annotation.buildSourceNamedStoredProcedureQuery2_1Annotation(parent, annotatedElement, index);
	}

	public NestableAnnotation buildAnnotation(JavaResourceAnnotatedElement parent, IAnnotation jdtAnnotation, int index) {
		return new BinaryNamedStoredProcedureQuery2_1Annotation(parent, jdtAnnotation);
	}

	public String getNestableAnnotationName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY;
	}

	public String getContainerAnnotationName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERIES;
	}

	public String getElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERIES__VALUE;
	}
}




package org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryNamedAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.source.SourceNamedAnnotation;
import org.eclipse.jpt.common.core.resource.java.Annotation;
import org.eclipse.jpt.common.core.resource.java.AnnotationDefinition;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement;
import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;

public final class StoredProcedureParameter2_1AnnotationDefinition
	implements AnnotationDefinition
{
	// singleton
	private static final AnnotationDefinition INSTANCE = new StoredProcedureParameter2_1AnnotationDefinition();

	/**
	 * Return the singleton.
	 */
	public static AnnotationDefinition instance() {
		return INSTANCE;
	}

	/**
	 * Ensure single instance.
	 */
	private StoredProcedureParameter2_1AnnotationDefinition() {
		super();
	}

	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, AnnotatedElement annotatedElement) {
		return new SourceNamedAnnotation(parent, annotatedElement, getAnnotationName());
	}

	public Annotation buildNullAnnotation(JavaResourceAnnotatedElement parent) {
		throw new UnsupportedOperationException();
	}

	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, IAnnotation jdtAnnotation) {
		return new BinaryNamedAnnotation(parent, jdtAnnotation, getAnnotationName());
	}

	public String getAnnotationName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER;
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java.binary;

import java.util.Vector;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.iterable.LiveCloneListIterable;
import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.internal.resource.java.binary.BinaryQueryAnnotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annoation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * javax.persistence.NamedStoredProcedureQuery
 */
public final class BinaryNamedStoredProcedureQuery2_1Annotation
	extends BinaryQueryAnnotation
	implements NamedStoredProcedureQuery2_1Annoation
{
	private String procedureName;
	private final Vector<StoredProcedureParameter2_1Annotation> parameters;
	private final Vector<String> resultClasses;
	private final Vector<String> resultSetMappings;


	public BinaryNamedStoredProcedureQuery2_1Annotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {
		super(parent, jdtAnnotation);
		this.procedureName = this.buildProcedureName();
		this.parameters = this.buildParameters();
		this.resultClasses = this.buildResultClasses();
		this.resultSetMappings = this.buildResultSetMappings();
	}

	@Override
	public void update() {
		super.update();
		this.setProcedureName_(this.buildProcedureName());
		this.updateParameters();
		this.updateResultClasses();
		this.updateResultSetMappings();
	}
	
	public String getAnnotationName() {
		return ANNOTATION_NAME;
	}
	
	// ********** BinaryNamedStoredProcedureQueryAnnotation implementation **********

	@Override
	public String getNameElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__NAME;
	}
	
	@Override
	public String getHintsElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__HINTS;
	}

	// ********** NamedStoredProcedureQueryAnnotation implementation **********
	
	//****** procedure name ******
	public String getProcedureName() {
		return this.procedureName;
	}

	public void setProcedureName(String procedureName) {
		throw new UnsupportedOperationException();
	}

	private void setProcedureName_(String procedureName) {
		String old = this.procedureName;
		this.procedureName = procedureName;
		this.firePropertyChanged(PROCEDURE_NAME_PROPERTY, old, procedureName);
	}

	private String buildProcedureName() {
		return (String) this.getJdtMemberValue(this.getProcedureNameElementName());
	}

	public String getProcedureNameElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__PROCEDURE_NAME;
	}

	public TextRange getProcedureNameTextRange() {
		throw new UnsupportedOperationException();
	}

	// ********* parameters ***********
	public ListIterable<StoredProcedureParameter2_1Annotation> getParameters() {
		return new LiveCloneListIterable<StoredProcedureParameter2_1Annotation>(this.parameters);
	}

	public int getParametersSize() {
		return this.parameters.size();
	}

	public StoredProcedureParameter2_1Annotation parameterAt(int index) {
		return this.parameters.get(index);
	}

	public StoredProcedureParameter2_1Annotation addParameter(int index) {
		throw new UnsupportedOperationException();
	}

	public void moveParameter(int targetIndex, int sourceIndex) {
		throw new UnsupportedOperationException();
	}

	public void removeParameter(int index) {
		throw new UnsupportedOperationException();
	}
	
	private Vector<StoredProcedureParameter2_1Annotation> buildParameters() {
		Object[] jdtParameters = this.getJdtMemberValues(this.getParametersElementName());
		Vector<StoredProcedureParameter2_1Annotation> result = new Vector<StoredProcedureParameter2_1Annotation>(jdtParameters.length);
		for (Object jdtParameter : jdtParameters) {
			result.add(new BinaryStoredProcedureParameter2_1Annotation(this, (IAnnotation) jdtParameter));
		}
		return result;
	}

	private String getParametersElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__PARAMETERS;
	}

	// TODO
	private void updateParameters() {
		throw new UnsupportedOperationException();
	}

	// *********** result classes **********
	public ListIterable<String> getResultClasses() {
		return new LiveCloneListIterable<String>(this.resultClasses);
	}

	public int getResultClassesSize() {
		return this.resultClasses.size();
	}

	public String resultClassAt(int index) {
		return this.resultClasses.elementAt(index);
	}

	public void addResultClass(String resultClass) {
		throw new UnsupportedOperationException();
	}

	public void addResultClass(int index, String resultClass) {
		throw new UnsupportedOperationException();
	}

	public void moveResultClass(int targetIndex, int sourceIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean resultClassTouches(int pos) {
		throw new UnsupportedOperationException();
	}

	public void removeResultClass(String resultClass) {
		throw new UnsupportedOperationException();
	}

	public void removeResultClass(int index) {
		throw new UnsupportedOperationException();
	}

	private Vector<String> buildResultClasses() {
		Object[] jdtResultClasses = this.getJdtMemberValues(this.getResultClassesElementName());
		Vector<String> result = new Vector<String>(jdtResultClasses.length);
		for (Object resultClass : jdtResultClasses) {
			result.add((String) resultClass);
		}
		return result;
	}
	
	private String getResultClassesElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_CLASSES;
	}
	
	//TODO
	private void updateResultClasses() {
		throw new UnsupportedOperationException();
	}

	// *********** result set mappings **********
	public ListIterable<String> getResultSetMappings() {
		return new LiveCloneListIterable<String>(this.resultSetMappings);
	}

	public int getResultSetMappingsSize() {
		return this.resultSetMappings.size();
	}

	public String resultSetMappingAt(int index) {
		return this.resultSetMappings.elementAt(index);
	}

	public void addResultSetMapping(String resultSetMapping) {
		throw new UnsupportedOperationException();
	}

	public void addResultSetMapping(int index, String resultSetMapping) {
		throw new UnsupportedOperationException();
	}

	public void moveResultSetMapping(int targetIndex, int sourceIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean resultSetMappingTouches(int pos) {
		throw new UnsupportedOperationException();
	}

	public void removeResultSetMapping(String resultSetMapping) {
		throw new UnsupportedOperationException();
	}

	public void removeResultSetMapping(int index) {
		throw new UnsupportedOperationException();
	}

	private Vector<String> buildResultSetMappings() {
		Object[] jdtResultSetMappings = this.getJdtMemberValues(this.getResultSetMappingsElementName());
		Vector<String> result = new Vector<String>(jdtResultSetMappings.length);
		for (Object resultSetMapping : jdtResultSetMappings) {
			result.add((String) resultSetMapping);
		}
		return result;
	}
	
	private String getResultSetMappingsElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_SET_MAPPINGS;
	}

	//TODO
	private void updateResultSetMappings() {
		throw new UnsupportedOperationException();
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java.binary;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryAnnotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * javax.persistence.StoredProcedureParameter
 */
public final class BinaryStoredProcedureParameter2_1Annotation 
	extends BinaryAnnotation
	implements StoredProcedureParameter2_1Annotation
{
	private String name;
	private ParameterMode2_1 mode;
	private String type;


	public BinaryStoredProcedureParameter2_1Annotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {
		super(parent, jdtAnnotation);
		this.name = this.buildName();
		this.mode = this.buildMode();
		this.type = this.buildType();
	}

	public String getAnnotationName() {
		return ANNOTATION_NAME;
	}

	@Override
	public void update() {
		super.update();
		this.setName_(this.buildName());
		this.setMode_(this.buildMode());
		this.setType_(this.buildType());
	}
	

	// ********** BinaryStoredProcedureParameterAnnotation implementation **********

	String getNameElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__NAME;
	}

	String getModeElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__MODE;
	}

	String getTypeElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__TYPE;
	}

	// ********** StoredProcedureParameterAnnotation implementation **********

	// ***** name
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		throw new UnsupportedOperationException();
	}

	private void setName_(String name) {
		String old = this.name;
		this.name = name;
		this.firePropertyChanged(NAME_PROPERTY, old, name);
	}

	private String buildName() {
		return (String) this.getJdtMemberValue(this.getNameElementName());
	}

	public TextRange getNameTextRange() {
		throw new UnsupportedOperationException();
	}
	
	// ***** mode
	public ParameterMode2_1 getMode() {
		return this.mode;
	}

	public void setMode(ParameterMode2_1 mode) {
		throw new UnsupportedOperationException();
	}

	private void setMode_(ParameterMode2_1 mode) {
		ParameterMode2_1 old = this.mode;
		this.mode = mode;
		this.firePropertyChanged(MODE_PROPERTY, old, mode);
	}

	private ParameterMode2_1 buildMode() {
		return ParameterMode2_1.fromJavaAnnotationValue(this.getJdtMemberValue(this.getModeElementName()));
	}

	public TextRange getModeTextRange() {
		throw new UnsupportedOperationException();
	}

	// ***** type
	public String getType() {
		return this.type;
	}

	public void setType(String type) {
		throw new UnsupportedOperationException();
	}

	private void setType_(String type) {
		String old = this.type;
		this.type = type;
		this.firePropertyChanged(TYPE_PROPERTY, old, type);
	}

	private String buildType() {
		return (String) this.getJdtMemberValue(this.getTypeElementName());
	}

	public TextRange getTypeTextRange() {
		throw new UnsupportedOperationException();
	}

	// ***** fully-qualified type name
	public String getFullyQualifiedTypeName()  {
		return this.type;
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java.source;

import java.util.Arrays;
import java.util.Vector;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jpt.common.core.internal.utility.jdt.AnnotatedElementAnnotationElementAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.AnnotationStringArrayExpressionConverter;
import org.eclipse.jpt.common.core.internal.utility.jdt.CombinationIndexedDeclarationAnnotationAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.ConversionDeclarationAnnotationElementAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.ElementIndexedAnnotationAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.SimpleDeclarationAnnotationAdapter;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
import org.eclipse.jpt.common.core.utility.jdt.AnnotationElementAdapter;
import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;
import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationElementAdapter;
import org.eclipse.jpt.common.core.utility.jdt.ExpressionConverter;
import org.eclipse.jpt.common.core.utility.jdt.IndexedAnnotationAdapter;
import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;
import org.eclipse.jpt.common.utility.internal.collection.ListTools;
import org.eclipse.jpt.common.utility.internal.iterable.LiveCloneListIterable;
import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.internal.resource.java.source.SourceQueryAnnotation;
import org.eclipse.jpt.jpa.core.internal.resource.java.source.SourceQueryHintAnnotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annoation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
import org.eclipse.jpt.jpa.core.resource.java.QueryHintAnnotation;

/**
 * <code>javax.persistence.NamedStoredProcedureQuery</code>
 */
public final class SourceNamedStoredProcedureQuery2_1Annotation
	extends SourceQueryAnnotation
	implements NamedStoredProcedureQuery2_1Annoation
{
	private static final DeclarationAnnotationAdapter DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(ANNOTATION_NAME);
	private static final DeclarationAnnotationAdapter CONTAINER_DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES);

	DeclarationAnnotationElementAdapter<String> procedureNameDeclarationAdapter;
	AnnotationElementAdapter<String> procedureNameAdapter;
	String procedureName;
	TextRange procedureNameTextRange;
	
	final StoredProcedureParameterAnnotationContainer storedProcedureParametersContainer = new StoredProcedureParameterAnnotationContainer();
	
	private DeclarationAnnotationElementAdapter<String[]> resultClassesDeclarationAdapter;
	private AnnotationElementAdapter<String[]> resultClassesAdapter;
	private final Vector<String> resultClasses = new Vector<String>();
	private TextRange resultClassesTextRange;
	
	/**
	 * TODO: Need to handle fullyQualifiedResultClassName/fqResultClassNameStale for each of the result classes
	    private final Vector<String> fullyQualifiedResultClassNames = new Vector<String>();
		// we need a flag since the f-q name can be null
		private boolean fqResultClassNameStale = true;
	 */

	private DeclarationAnnotationElementAdapter<String[]> resultSetMappingsDeclarationAdapter;
	private AnnotationElementAdapter<String[]> resultSetMappingsAdapter;
	private final Vector<String> resultSetMappings = new Vector<String>();
	private TextRange resultSetMappingsTextRange;

	public static SourceNamedStoredProcedureQuery2_1Annotation buildSourceNamedStoredProcedureQuery2_1Annotation(
			JavaResourceAnnotatedElement parent, 
			AnnotatedElement element, 
			int index)
	{
		IndexedDeclarationAnnotationAdapter idaa = buildNamedStoredProcedureQuery2_1DeclarationAnnotationAdapter(index);
		IndexedAnnotationAdapter iaa = buildNamedStoredProcedureQuery2_1AnnotationAdapter(element, idaa);
		return new SourceNamedStoredProcedureQuery2_1Annotation(
			parent,
			element,
			idaa,
			iaa);
	}

	private SourceNamedStoredProcedureQuery2_1Annotation(
			JavaResourceAnnotatedElement parent,
			AnnotatedElement element,
			IndexedDeclarationAnnotationAdapter daa,
			IndexedAnnotationAdapter annotationAdapter)
	{
		super(parent, element, daa, annotationAdapter);
		this.procedureNameDeclarationAdapter = this.buildProcedureNameDeclarationAdapter();
		this.procedureNameAdapter = this.buildProcedureNameAdapter();
		this.resultClassesDeclarationAdapter = this.buildResultClassesDeclarationAdapter();
		this.resultClassesAdapter = this.buildResultClassesAdapter();
		this.resultSetMappingsDeclarationAdapter = this.buildResultSetMappingsDeclarationAdapter();
		this.resultSetMappingsAdapter = this.buildResultSetMappingsAdapter();
	}

	public String getAnnotationName() {
		return ANNOTATION_NAME;
	}

	@Override
	public void initialize(Annotation astAnnotation) {
		super.initialize(astAnnotation);
		
		this.procedureName = this.buildProcedureName(astAnnotation);
		this.procedureNameTextRange = this.buildProcedureNameTextRange(astAnnotation);

		this.storedProcedureParametersContainer.initializeFromContainerAnnotation(astAnnotation);
		
		this.initializeResultClasses(astAnnotation);
		this.resultClassesTextRange = this.buildResultClassesTextRange(astAnnotation);

		this.initializeResultSetMappings(astAnnotation);
		this.resultSetMappingsTextRange = this.buildResultSetMappingsTextRange(astAnnotation);
	}

	@Override
	public void synchronizeWith(Annotation astAnnotation) {
		super.synchronizeWith(astAnnotation);
		
		this.syncProcedureName(this.buildProcedureName(astAnnotation));
		this.procedureNameTextRange = this.buildProcedureNameTextRange(astAnnotation);

		this.storedProcedureParametersContainer.synchronize(astAnnotation);
		
		this.syncResultClasses(astAnnotation);
		this.resultClassesTextRange = this.buildResultClassesTextRange(astAnnotation);
		
		this.syncResultSetMappings(astAnnotation);
		this.resultSetMappingsTextRange = this.buildResultSetMappingsTextRange(astAnnotation);
	
	}

	// ********** AbstractNamedStoredProcedureQuery2_1Annotation implementation **********

	@Override
	public String getNameElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__NAME;
	}

	@Override
	public String getHintsElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__HINTS;
	}

	@Override
	public QueryHintAnnotation buildHint(int index) {
		return SourceQueryHintAnnotation.buildNamedStoredProcedureQuery2_1QueryHint(this, this.annotatedElement, this.daa, index);
	}


	// ********** NamedStoredProcedureQuery2_1Annotation implementation **********
	
	String getProcedureNameElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__PROCEDURE_NAME;
	}
	
	String getParametersElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__PARAMETERS;
	}
	
	public StoredProcedureParameter2_1Annotation buildParameter(int index) {
		return SourceStoredProcedureParameter2_1Annotation.buildNamedStoredProcedureQuery2_1Parameter(this, this.annotatedElement, this.daa, index);
	}

	String getResultClassesElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_CLASSES;
	}

	String getResultSetMappingsElementName() {
		return JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_SET_MAPPINGS;
	}

	// ***** procedure name
	public String getProcedureName() {
		return this.procedureName;
	}

	public void setProcedureName(String procedureName) {
		if (this.attributeValueHasChanged(this.procedureName, procedureName)) {
			this.procedureName = procedureName;
			this.procedureNameAdapter.setValue(procedureName);
		}
	}

	private void syncProcedureName(String procedureName) {
		String old = this.procedureName;
		this.procedureName = procedureName;
		this.firePropertyChanged(PROCEDURE_NAME_PROPERTY, old, procedureName);
	}

	private String buildProcedureName(Annotation astAnnotation) {
		return this.procedureNameAdapter.getValue(astAnnotation);
	}

	public TextRange getProcedureNameTextRange() {
		return this.procedureNameTextRange;
	}

	private TextRange buildProcedureNameTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.procedureNameDeclarationAdapter, astAnnotation);
	}

	private DeclarationAnnotationElementAdapter<String> buildProcedureNameDeclarationAdapter() {
		return ConversionDeclarationAnnotationElementAdapter.forStrings(this.daa, this.getProcedureNameElementName());
	}

	private AnnotationElementAdapter<String> buildProcedureNameAdapter() {
		return this.buildStringElementAdapter(this.procedureNameDeclarationAdapter);
	}


	// ***** parameters
	public ListIterable<StoredProcedureParameter2_1Annotation> getParameters() {
		return this.storedProcedureParametersContainer.getNestedAnnotations();
	}

	public int getParametersSize() {
		return this.storedProcedureParametersContainer.getNestedAnnotationsSize();
	}

	public StoredProcedureParameter2_1Annotation parameterAt(int index) {
		return this.storedProcedureParametersContainer.getNestedAnnotation(index);
	}

	public StoredProcedureParameter2_1Annotation addParameter(int index) {
		return this.storedProcedureParametersContainer.addNestedAnnotation(index);
	}

	public void moveParameter(int targetIndex, int sourceIndex) {
		this.storedProcedureParametersContainer.moveNestedAnnotation(targetIndex, sourceIndex);
	}

	public void removeParameter(int index) {
		this.storedProcedureParametersContainer.removeNestedAnnotation(index);
	}


	// ***** result classes
	public ListIterable<String> getResultClasses() {
		return new LiveCloneListIterable<String>(this.resultClasses);
	}

	public int getResultClassesSize() {
		return this.resultClasses.size();
	}

	public String resultClassAt(int index) {
		return this.resultClasses.elementAt(index);
	}

	public void addResultClass(String resultClass) {
		this.addResultClass(this.resultClasses.size(), resultClass);
	}

	public void addResultClass(int index, String resultClass) {
		this.resultClasses.add(index, resultClass);
		this.writeResultClasses();
	}

	public void moveResultClass(int targetIndex, int sourceIndex) {
		ListTools.move(this.resultClasses, targetIndex, sourceIndex);
		this.writeResultClasses();
	}

	public void removeResultClass(String resultClass) {
		this.resultClasses.remove(resultClass);
		this.writeResultClasses();
	}

	public void removeResultClass(int index) {
		this.resultClasses.remove(index);
		this.writeResultClasses();
	}

	private void writeResultClasses() {
		this.resultClassesAdapter.setValue(this.resultClasses.toArray(new String[this.resultClasses.size()]));
	}

	private void initializeResultClasses(Annotation astAnnotation) {
		String[] astResultClasses = this.resultClassesAdapter.getValue(astAnnotation);
		for (int i = 0; i < astResultClasses.length; i++) {
			this.resultClasses.add(astResultClasses[i]);
		}
	}

	private void syncResultClasses(Annotation astAnnotation) {
		String[] javaResultClasses = this.resultClassesAdapter.getValue(astAnnotation);
		this.synchronizeList(Arrays.asList(javaResultClasses), this.resultClasses, RESULT_CLASSES_LIST);
	}

	private TextRange buildResultClassesTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.resultClassesDeclarationAdapter, astAnnotation);
	}

	public boolean resultClassesTouches(int pos) {
		return this.textRangeTouches(this.resultClassesTextRange, pos);
	}

	private DeclarationAnnotationElementAdapter<String[]> buildResultClassesDeclarationAdapter() {
		return buildResultClassesArrayAnnotationElementAdapter(this.daa, JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_CLASSES);
	}

	private AnnotationElementAdapter<String[]> buildResultClassesAdapter() {
		return this.buildAnnotationElementAdapter(this.resultClassesDeclarationAdapter);
	}


	// ***** result set mappings
	public ListIterable<String> getResultSetMappings() {
		return new LiveCloneListIterable<String>(this.resultSetMappings);
	}

	public int getResultSetMappingsSize() {
		return this.resultSetMappings.size();
	}

	public String resultSetMappingAt(int index) {
		return this.resultSetMappings.elementAt(index);
	}

	public void addResultSetMapping(String resultClass) {
		this.addResultSetMapping(this.resultSetMappings.size(), resultClass);
	}

	public void addResultSetMapping(int index, String resultClass) {
		this.resultSetMappings.add(index, resultClass);
		this.writeResultSetMappings();
	}

	public void moveResultSetMapping(int targetIndex, int sourceIndex) {
		ListTools.move(this.resultSetMappings, targetIndex, sourceIndex);
		this.writeResultSetMappings();
	}

	public void removeResultSetMapping(String resultSetMapping) {
		this.resultSetMappings.remove(resultSetMapping);
		this.writeResultSetMappings();
	}

	public void removeResultSetMapping(int index) {
		this.resultSetMappings.remove(index);
		this.writeResultSetMappings();
	}

	private void writeResultSetMappings() {
		this.resultSetMappingsAdapter.setValue(this.resultSetMappings.toArray(new String[this.resultSetMappings.size()]));
	}

	private void initializeResultSetMappings(Annotation astAnnotation) {
		String[] astResultClasses = this.resultSetMappingsAdapter.getValue(astAnnotation);
		for (int i = 0; i < astResultClasses.length; i++) {
			this.resultSetMappings.add(astResultClasses[i]);
		}
	}

	private void syncResultSetMappings(Annotation astAnnotation) {
		String[] javaResultClasses = this.resultSetMappingsAdapter.getValue(astAnnotation);
		this.synchronizeList(Arrays.asList(javaResultClasses), this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	}

	private TextRange buildResultSetMappingsTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.resultSetMappingsDeclarationAdapter, astAnnotation);
	}

	public boolean resultSetMappingsTouches(int pos) {
		return this.textRangeTouches(this.resultSetMappingsTextRange, pos);
	}

	private DeclarationAnnotationElementAdapter<String[]> buildResultSetMappingsDeclarationAdapter() {
		return buildResultSetMappingsArrayAnnotationElementAdapter(this.daa, JPA2_1.NAMED_STORED_PROCEDURE_QUERY__RESULT_SET_MAPPINGS);
	}

	private AnnotationElementAdapter<String[]> buildResultSetMappingsAdapter() {
		return this.buildAnnotationElementAdapter(this.resultSetMappingsDeclarationAdapter);
	}
	
	// **********
	private AnnotationElementAdapter<String[]> buildAnnotationElementAdapter(DeclarationAnnotationElementAdapter<String[]> daea) {
		return new AnnotatedElementAnnotationElementAdapter<String[]>(this.annotatedElement, daea);
	}

	private static DeclarationAnnotationElementAdapter<String[]> buildResultClassesArrayAnnotationElementAdapter(
			DeclarationAnnotationAdapter annotationAdapter,
			String elementName)
	{
		return buildArrayAnnotationElementAdapter(
				annotationAdapter,
				elementName,
				AnnotationStringArrayExpressionConverter.forTypes());
	}
	
	private static DeclarationAnnotationElementAdapter<String[]> buildResultSetMappingsArrayAnnotationElementAdapter(
			DeclarationAnnotationAdapter annotationAdapter,
			String elementName)
	{
		return buildArrayAnnotationElementAdapter(
				annotationAdapter,
				elementName,
				AnnotationStringArrayExpressionConverter.forStrings());
	}

	private static DeclarationAnnotationElementAdapter<String[]> buildArrayAnnotationElementAdapter(
			DeclarationAnnotationAdapter annotationAdapter,
			String elementName,
			ExpressionConverter<String[]> converter)
	{
		return new ConversionDeclarationAnnotationElementAdapter<String[]>(
				annotationAdapter,
				elementName,
				converter);
	}


	// ********** stored procedure parameter container **********
	/**
	 * adapt the AnnotationContainer interface to the xml schema's xmlns
	 */
	class StoredProcedureParameterAnnotationContainer
		extends AnnotationContainer<StoredProcedureParameter2_1Annotation>
	{
		@Override
		protected String getNestedAnnotationsListName() {
			return PARAMETERS_LIST;
		}
		@Override
		protected String getElementName() {
			return SourceNamedStoredProcedureQuery2_1Annotation.this.getParametersElementName();
		}
		@Override
		protected String getNestedAnnotationName() {
			return StoredProcedureParameter2_1Annotation.ANNOTATION_NAME;
		}
		@Override
		protected StoredProcedureParameter2_1Annotation buildNestedAnnotation(int index) {
			return SourceNamedStoredProcedureQuery2_1Annotation.this.buildParameter(index);
		}
	}

	// ********** misc **********

	@Override
	public boolean isUnset() {
		return super.isUnset() &&
				(this.procedureName == null) &&
				(this.storedProcedureParametersContainer.isEmpty()) &&
				(this.resultClasses.isEmpty()) &&
				(this.resultSetMappings.isEmpty());
	}

	// ********** static methods **********

	private static IndexedAnnotationAdapter buildNamedStoredProcedureQuery2_1AnnotationAdapter(
			AnnotatedElement annotatedElement,
			IndexedDeclarationAnnotationAdapter idaa)
	{
		return new ElementIndexedAnnotationAdapter(annotatedElement, idaa);
	}

	private static IndexedDeclarationAnnotationAdapter buildNamedStoredProcedureQuery2_1DeclarationAnnotationAdapter(int index) 
	{
		return new CombinationIndexedDeclarationAnnotationAdapter(
				DECLARATION_ANNOTATION_ADAPTER,
				CONTAINER_DECLARATION_ANNOTATION_ADAPTER,
				index,
				ANNOTATION_NAME);
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java.source;

import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jpt.common.core.internal.resource.java.source.SourceAnnotation;
import org.eclipse.jpt.common.core.internal.utility.jdt.ASTTools;
import org.eclipse.jpt.common.core.internal.utility.jdt.ConversionDeclarationAnnotationElementAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.ElementIndexedAnnotationAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.EnumDeclarationAnnotationElementAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.NestedIndexedDeclarationAnnotationAdapter;
import org.eclipse.jpt.common.core.internal.utility.jdt.TypeStringExpressionConverter;
import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
import org.eclipse.jpt.common.core.utility.jdt.AnnotationElementAdapter;
import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;
import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationElementAdapter;
import org.eclipse.jpt.common.core.utility.jdt.ExpressionConverter;
import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * <code>javax.persistence.StoredProcedureParameter</code>
 */
public final class SourceStoredProcedureParameter2_1Annotation 
	extends SourceAnnotation
	implements StoredProcedureParameter2_1Annotation
{
	private DeclarationAnnotationElementAdapter<String> nameDeclarationAdapter;
	private AnnotationElementAdapter<String> nameAdapter;
	private String name;
	private TextRange nameTextRange;

	private DeclarationAnnotationElementAdapter<String> modeDeclarationAdapter;
	private AnnotationElementAdapter<String> modeAdapter;
	private ParameterMode2_1 mode;
	private TextRange modeTextRange;

	private DeclarationAnnotationElementAdapter<String> typeDeclarationAdapter;
	private AnnotationElementAdapter<String> typeAdapter;
	private String type;
	private TextRange typeTextRange;

	private String fullyQualifiedTypeName;
	// we need a flag since the f-q name can be null
	private boolean fqTypeNameStale = true;
	
	public static SourceStoredProcedureParameter2_1Annotation buildNamedStoredProcedureQuery2_1Parameter(
			JavaResourceNode parent,
			AnnotatedElement element,
			DeclarationAnnotationAdapter namedStoredProcedureQueryAdapter,
			int index)
	{
		return buildNestedSourceStoredProcedureParameter2_1Annotation(
				parent,
				element,
				buildStoredProcedureParameter2_1AnnotationAdapter(namedStoredProcedureQueryAdapter,
				index));
	}

	
	public static SourceStoredProcedureParameter2_1Annotation buildNestedSourceStoredProcedureParameter2_1Annotation(
			JavaResourceNode parent, 
			AnnotatedElement element, 
			IndexedDeclarationAnnotationAdapter idaa) 
	{
		return new SourceStoredProcedureParameter2_1Annotation(
				parent,
				element,
				idaa);
	}

	private SourceStoredProcedureParameter2_1Annotation(
			JavaResourceNode parent,
			AnnotatedElement element,
			IndexedDeclarationAnnotationAdapter idaa)
	{
		super(parent, element, idaa, new ElementIndexedAnnotationAdapter(element, idaa));
		this.nameDeclarationAdapter = this.buildNameDeclarationAdapter();
		this.nameAdapter = this.buildNameAdapter();
		this.modeDeclarationAdapter = this.buildModeDeclarationAdapter();
		this.modeAdapter = this.buildModeAdapter();
		this.typeDeclarationAdapter = this.buildTypeDeclarationAdapter();
		this.typeAdapter = this.buildTypeAdapter();
	}

	public String getAnnotationName() {
		return ANNOTATION_NAME;
	}

	@Override
	public void initialize(Annotation astAnnotation) {
		super.initialize(astAnnotation);
		this.name = this.buildName(astAnnotation);
		this.nameTextRange = this.buildNameTextRange(astAnnotation);

		this.mode = this.buildMode(astAnnotation);
		this.modeTextRange = this.buildModeTextRange(astAnnotation);

		this.type = this.buildType(astAnnotation);
		this.typeTextRange = this.buildTypeTextRange(astAnnotation);
	}

	@Override
	public void synchronizeWith(Annotation astAnnotation) {
		super.synchronizeWith(astAnnotation);
		this.syncName(this.buildName(astAnnotation));
		this.nameTextRange = this.buildNameTextRange(astAnnotation);

		this.syncMode(this.buildMode(astAnnotation));
		this.modeTextRange = this.buildModeTextRange(astAnnotation);

		this.syncType(this.buildType(astAnnotation));
		this.typeTextRange = this.buildTypeTextRange(astAnnotation);
	}


	// ********** StoredProcedureParameterAnnotation implementation **********

	// ***** name
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		if (this.attributeValueHasChanged(this.name, name)) {
			this.name = name;
			this.nameAdapter.setValue(name);
		}
	}

	private void syncName(String astName) {
		String old = this.name;
		this.name = astName;
		this.firePropertyChanged(NAME_PROPERTY, old, astName);
	}

	private String buildName(Annotation astAnnotation) {
		return this.nameAdapter.getValue(astAnnotation);
	}

	public TextRange getNameTextRange() {
		return this.nameTextRange;
	}

	private TextRange buildNameTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.nameDeclarationAdapter, astAnnotation);
	}

	private DeclarationAnnotationElementAdapter<String> buildNameDeclarationAdapter() {
		return ConversionDeclarationAnnotationElementAdapter.forStrings(this.daa, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__NAME);
	}

	private AnnotationElementAdapter<String> buildNameAdapter() {
		return this.buildStringElementAdapter(this.nameDeclarationAdapter);
	}

	// ***** mode
	public ParameterMode2_1 getMode() {
		return this.mode;
	}

	public void setMode(ParameterMode2_1 mode) {
		if (this.attributeValueHasChanged(this.mode, mode)) {
			this.mode = mode;
			this.modeAdapter.setValue(ParameterMode2_1.toJavaAnnotationValue(mode));
		}
	}

	private void syncMode(ParameterMode2_1 astValue) {
		ParameterMode2_1 old = this.mode;
		this.mode = astValue;
		this.firePropertyChanged(MODE_PROPERTY, old, astValue);
	}

	private ParameterMode2_1 buildMode(Annotation astAnnotation) {
		return ParameterMode2_1.fromJavaAnnotationValue(this.modeAdapter.getValue(astAnnotation));
	}

	public TextRange getModeTextRange() {
		return this.modeTextRange;
	}

	private TextRange buildModeTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.modeDeclarationAdapter, astAnnotation);
	}

	private DeclarationAnnotationElementAdapter<String> buildModeDeclarationAdapter() {
		return new EnumDeclarationAnnotationElementAdapter(this.daa, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__MODE);
	}

	private AnnotationElementAdapter<String> buildModeAdapter() {
		return this.buildStringElementAdapter(this.modeDeclarationAdapter);
	}
	
	// ***** type
	public String getType() {
		return this.type;
	}

	public void setType(String type) {
		if (this.attributeValueHasChanged(this.type, type)) {
			this.type = type;
			this.fqTypeNameStale = true;
			this.typeAdapter.setValue(type);
		}
	}
	
	private void syncType(String astType) {
		if (this.attributeValueHasChanged(this.type, astType)) {
			this.syncType_(astType);
		}
	}

	private void syncType_(String astType) {
		String old = this.type;
		this.type = astType;
		this.fqTypeNameStale = true;
		this.firePropertyChanged(TYPE_PROPERTY, old, astType);
	}

	private String buildType(Annotation astAnnotation) {
		return this.typeAdapter.getValue(astAnnotation);
	}

	public TextRange getTypeTextRange() {
		return this.typeTextRange;
	}

	private TextRange buildTypeTextRange(Annotation astAnnotation) {
		return this.getElementTextRange(this.typeDeclarationAdapter, astAnnotation);
	}

	private DeclarationAnnotationElementAdapter<String> buildTypeDeclarationAdapter() {
		return buildTypeDeclarationAdapter(this.daa, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER__TYPE);
	}

	private static DeclarationAnnotationElementAdapter<String> buildTypeDeclarationAdapter(
			DeclarationAnnotationAdapter annotationAdapter,
			String elementName)
	{
		return buildAnnotationElementAdapter(
				annotationAdapter, 
				elementName, 
				TypeStringExpressionConverter.instance());
	}

	private static DeclarationAnnotationElementAdapter<String> buildAnnotationElementAdapter(
			DeclarationAnnotationAdapter annotationAdapter,
			String elementName,
			ExpressionConverter<String> converter)
	{
		return new ConversionDeclarationAnnotationElementAdapter<String>(
				annotationAdapter,
				elementName,
				converter);
	}

	private AnnotationElementAdapter<String> buildTypeAdapter() {
		return this.buildStringElementAdapter(this.typeDeclarationAdapter);
	}
	
	// ***** fully-qualified type name
	public String getFullyQualifiedTypeName()  {
		if (this.fqTypeNameStale) {
			this.fullyQualifiedTypeName = this.buildFullyQualifiedTypeName();
			this.fqTypeNameStale = false;
		}
		return this.fullyQualifiedTypeName;
	}

	private String buildFullyQualifiedTypeName() {
		return (this.type == null) ? null : this.buildFullyQualifiedTypeName_();
	}

	private String buildFullyQualifiedTypeName_() {
		return ASTTools.resolveFullyQualifiedName(this.typeAdapter.getExpression(this.buildASTRoot()));
	}


	// ********** misc **********

	@Override
	public boolean isUnset() {
		return super.isUnset() &&
				(this.name == null) &&
				(this.mode == null) &&
				(this.type == null);
	}

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


	// ********** static methods **********
	private static IndexedDeclarationAnnotationAdapter buildStoredProcedureParameter2_1AnnotationAdapter(
			DeclarationAnnotationAdapter namedStoredProcedureQuery2_1Adapter,
			int index)
	{
		return new NestedIndexedDeclarationAnnotationAdapter(
				namedStoredProcedureQuery2_1Adapter,
				JPA2_1.NAMED_STORED_PROCEDURE_QUERY__PARAMETERS,
				index,
				ANNOTATION_NAME);
	}

}




/*******************************************************************************
 * Copyright (c) 2009, 2013 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.jpa.core.internal.resource.java.binary;

import java.util.List;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
import org.eclipse.jpt.common.core.utility.TextRange;

	extends BinaryQueryAnnotation
	implements NamedNativeQueryAnnotation
{
	private String query;
	private String resultClass;
	private String resultSetMapping;


	public BinaryNamedNativeQueryAnnotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {
		super(parent, jdtAnnotation);
		this.query = this.buildQuery();
		this.resultClass = this.buildResultClass();
		this.resultSetMapping = this.buildResultSetMapping();
	}

	@Override
	public void update() {
		super.update();
		this.setQuery_(this.buildQuery());
		this.setResultClass_(this.buildResultClass());
		this.setResultSetMapping_(this.buildResultSetMapping());
	}


	// ********** BinaryNamedNativeQueryAnnotation implementation **********

	@Override
	public String getNameElementName() {
		return JPA.NAMED_NATIVE_QUERY__NAME;
	}

	@Override
	public String getHintsElementName() {
		return JPA.NAMED_NATIVE_QUERY__QUERY;
	}

	@Override
	String getHintsElementName() {
		return JPA.NAMED_NATIVE_QUERY__HINTS;
	}


	// ********** NamedNativeQueryAnnotation implementation **********

	String getQueryElementName() {
		return JPA.NAMED_NATIVE_QUERY__QUERY;
	}

	// ***** query
	public String getQuery() {
		return this.query;
	}

	public void setQuery(String query) {
		throw new UnsupportedOperationException();
	}

	private void setQuery_(String query) {
		String old = this.query;
		this.query = query;
		this.firePropertyChanged(QUERY_PROPERTY, old, query);
	}

	private String buildQuery() {
		return (String) this.getJdtMemberValue(this.getQueryElementName());
	}

	public List<TextRange> getQueryTextRanges() {
		throw new UnsupportedOperationException();
	}

	// ***** result class
	public String getResultClass() {
		return this.resultClass;

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/resource/java/binary/BinaryNamedQueryAnnotation.java (-5 / +41 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2009, 2011 Oracle. All rights reserved.	2	* Copyright (c) 2009, 2013 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-16 Link Here
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.resource.java.binary;	10	package org.eclipse.jpt.jpa.core.internal.resource.java.binary;
11		11
		12	import java.util.List;
12	import org.eclipse.jdt.core.IAnnotation;	13	import org.eclipse.jdt.core.IAnnotation;
13	import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;	14	import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
		15	import org.eclipse.jpt.common.core.utility.TextRange;
14	import org.eclipse.jpt.jpa.core.resource.java.JPA;	16	import org.eclipse.jpt.jpa.core.resource.java.JPA;
15	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;	17	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;
16		18
Lines 21-50 Link Here
21	extends BinaryQueryAnnotation	23	extends BinaryQueryAnnotation
22	implements NamedQueryAnnotation	24	implements NamedQueryAnnotation
23	{	25	{
		26	private String query;
		27
24	public BinaryNamedQueryAnnotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {	28	public BinaryNamedQueryAnnotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {
25	super(parent, jdtAnnotation);	29	super(parent, jdtAnnotation);
		30	this.query = this.buildQuery();
26	}	31	}
27		32
28	public String getAnnotationName() {	33	public String getAnnotationName() {
29	return ANNOTATION_NAME;	34	return ANNOTATION_NAME;
30	}	35	}
31		36
		37	@Override
		38	public void update() {
		39	super.update();
		40	this.setQuery_(this.buildQuery());
		41	}
32		42
33	// ******** BinaryBaseNamedQueryAnnotation implementation ********	43
		44	// ******** BinaryNamedQueryAnnotation implementation ********
34		45
35	@Override	46	@Override
36	String getNameElementName() {	47	public String getNameElementName() {
37	return JPA.NAMED_QUERY__NAME;	48	return JPA.NAMED_QUERY__NAME;
38	}	49	}
39		50
40	@Override
41	String getQueryElementName() {	51	String getQueryElementName() {
42	return JPA.NAMED_QUERY__QUERY;	52	return JPA.NAMED_QUERY__QUERY;
43	}	53	}
44		54
45	@Override	55	@Override
46	String getHintsElementName() {	56	public String getHintsElementName() {
47	return JPA.NAMED_QUERY__HINTS;	57	return JPA.NAMED_QUERY__HINTS;
48	}	58	}
49		59
		60
		61	// ******** NamedNativeQueryAnnotation implementation ********
		62
		63	// ***** query
		64	public String getQuery() {
		65	return this.query;
		66	}
		67
		68	public void setQuery(String query) {
		69	throw new UnsupportedOperationException();
		70	}
		71
		72	private void setQuery_(String query) {
		73	String old = this.query;
		74	this.query = query;
		75	this.firePropertyChanged(QUERY_PROPERTY, old, query);
		76	}
		77
		78	private String buildQuery() {
		79	return (String) this.getJdtMemberValue(this.getQueryElementName());
		80	}
		81
		82	public List<TextRange> getQueryTextRanges() {
		83	throw new UnsupportedOperationException();
		84	}
		85
50	}	86	}




 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.resource.java.binary;

import java.util.List;
import java.util.Vector;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryAnnotation;

/**
 * javax.persistence.NamedQuery
 * javax.persistence.NamedNativeQuery
 * javax.persistence.NamedStoredProcedureQuery
 */
public abstract class BinaryQueryAnnotation
	extends BinaryAnnotation
	implements QueryAnnotation
{
	String name;
	String query;
	final Vector<QueryHintAnnotation> hints;


	protected BinaryQueryAnnotation(JavaResourceNode parent, IAnnotation jdtAnnotation) {
		super(parent, jdtAnnotation);
		this.name = this.buildName();
		this.query = this.buildQuery();
		this.hints = this.buildHints();
	}


	public void update() {
		super.update();
		this.setName_(this.buildName());
		this.setQuery_(this.buildQuery());
		this.updateHints();
	}


		return (String) this.getJdtMemberValue(this.getNameElementName());
	}

	public abstract String getNameElementName();

	public TextRange getNameTextRange() {
		throw new UnsupportedOperationException();
	}

	// ***** query
	public String getQuery() {
		return this.query;
	}

	public void setQuery(String query) {
		throw new UnsupportedOperationException();
	}

	private void setQuery_(String query) {
		String old = this.query;
		this.query = query;
		this.firePropertyChanged(QUERY_PROPERTY, old, query);
	}

	private String buildQuery() {
		return (String) this.getJdtMemberValue(this.getQueryElementName());
	}

	abstract String getQueryElementName();

	public List<TextRange> getQueryTextRanges() {
		throw new UnsupportedOperationException();
	}


		return result;
	}

	public abstract String getHintsElementName();

	// TODO
	private void updateHints() {

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/resource/java/source/SourceNamedNativeQueryAnnotation.java (-10 / +62 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2012 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2013 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-14 Link Here
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.resource.java.source;	10	package org.eclipse.jpt.jpa.core.internal.resource.java.source;
11		11
		12	import java.util.List;
12	import org.eclipse.jdt.core.dom.Annotation;	13	import org.eclipse.jdt.core.dom.Annotation;
13	import org.eclipse.jpt.common.core.internal.utility.jdt.ASTTools;	14	import org.eclipse.jpt.common.core.internal.utility.jdt.ASTTools;
14	import org.eclipse.jpt.common.core.internal.utility.jdt.CombinationIndexedDeclarationAnnotationAdapter;	15	import org.eclipse.jpt.common.core.internal.utility.jdt.CombinationIndexedDeclarationAnnotationAdapter;
Lines 37-42 Link Here
37	{	38	{
38	private static final DeclarationAnnotationAdapter DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(ANNOTATION_NAME);	39	private static final DeclarationAnnotationAdapter DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(ANNOTATION_NAME);
39	private static final DeclarationAnnotationAdapter CONTAINER_DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(JPA.NAMED_NATIVE_QUERIES);	40	private static final DeclarationAnnotationAdapter CONTAINER_DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(JPA.NAMED_NATIVE_QUERIES);
		41
		42	DeclarationAnnotationElementAdapter<String> queryDeclarationAdapter;
		43	AnnotationElementAdapter<String> queryAdapter;
		44	String query;
		45	List<TextRange> queryTextRanges;
40		46
41	private DeclarationAnnotationElementAdapter<String> resultClassDeclarationAdapter;	47	private DeclarationAnnotationElementAdapter<String> resultClassDeclarationAdapter;
42	private AnnotationElementAdapter<String> resultClassAdapter;	48	private AnnotationElementAdapter<String> resultClassAdapter;
Lines 71-76 Link Here
71	IndexedDeclarationAnnotationAdapter daa,	77	IndexedDeclarationAnnotationAdapter daa,
72	IndexedAnnotationAdapter annotationAdapter) {	78	IndexedAnnotationAdapter annotationAdapter) {
73	super(parent, element, daa, annotationAdapter);	79	super(parent, element, daa, annotationAdapter);
		80	this.queryDeclarationAdapter = this.buildQueryDeclarationAdapter();
		81	this.queryAdapter = this.buildQueryAdapter();
74	this.resultClassDeclarationAdapter = this.buildResultClassDeclarationAdapter();	82	this.resultClassDeclarationAdapter = this.buildResultClassDeclarationAdapter();
75	this.resultClassAdapter = this.buildResultClassAdapter();	83	this.resultClassAdapter = this.buildResultClassAdapter();
76	this.resultSetMappingDeclarationAdapter = this.buildResultSetMappingAdapter(daa);	84	this.resultSetMappingDeclarationAdapter = this.buildResultSetMappingAdapter(daa);
Lines 84-89 Link Here
84	@Override	92	@Override
85	public void initialize(Annotation astAnnotation) {	93	public void initialize(Annotation astAnnotation) {
86	super.initialize(astAnnotation);	94	super.initialize(astAnnotation);
		95
		96	this.query = this.buildQuery(astAnnotation);
		97	this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
87		98
88	this.resultClass = this.buildResultClass(astAnnotation);	99	this.resultClass = this.buildResultClass(astAnnotation);
89	this.resultClassTextRange = this.buildResultClassTextRange(astAnnotation);	100	this.resultClassTextRange = this.buildResultClassTextRange(astAnnotation);
Lines 95-100 Link Here
95	@Override	106	@Override
96	public void synchronizeWith(Annotation astAnnotation) {	107	public void synchronizeWith(Annotation astAnnotation) {
97	super.synchronizeWith(astAnnotation);	108	super.synchronizeWith(astAnnotation);
		109
		110	this.syncQuery(this.buildQuery(astAnnotation));
		111	this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
98		112
99	this.syncResultClass(this.buildResultClass(astAnnotation));	113	this.syncResultClass(this.buildResultClass(astAnnotation));
100	this.resultClassTextRange = this.buildResultClassTextRange(astAnnotation);	114	this.resultClassTextRange = this.buildResultClassTextRange(astAnnotation);
Lines 104-133 Link Here
104	}	118	}
105		119
106		120
107	// ******** AbstractBaseNamedQueryAnnotation implementation ********	121	// ******** AbstractNamedNativeQueryAnnotation implementation ********
108		122
109	@Override	123	@Override
110	String getNameElementName() {	124	public String getNameElementName() {
111	return JPA.NAMED_NATIVE_QUERY__NAME;	125	return JPA.NAMED_NATIVE_QUERY__NAME;
112	}	126	}
113		127
114	@Override	128	@Override
115	String getQueryElementName() {	129	public String getHintsElementName() {
116	return JPA.NAMED_NATIVE_QUERY__QUERY;
117	}
118
119	@Override
120	String getHintsElementName() {
121	return JPA.NAMED_NATIVE_QUERY__HINTS;	130	return JPA.NAMED_NATIVE_QUERY__HINTS;
122	}	131	}
123		132
124	@Override	133	@Override
125	QueryHintAnnotation buildHint(int index) {	134	public QueryHintAnnotation buildHint(int index) {
126	return SourceQueryHintAnnotation.buildNamedNativeQueryQueryHint(this, this.annotatedElement, this.daa, index);	135	return SourceQueryHintAnnotation.buildNamedNativeQueryQueryHint(this, this.annotatedElement, this.daa, index);
127	}	136	}
128		137
129		138
130	// ******** NamedNativeQueryAnnotation implementation ********	139	// ******** NamedNativeQueryAnnotation implementation ********
		140
		141	String getQueryElementName() {
		142	return JPA.NAMED_NATIVE_QUERY__QUERY;
		143	}
		144
		145	// ***** query
		146	public String getQuery() {
		147	return this.query;
		148	}
		149
		150	public void setQuery(String query) {
		151	if (this.attributeValueHasChanged(this.query, query)) {
		152	this.query = query;
		153	this.queryAdapter.setValue(query);
		154	}
		155	}
		156
		157	private void syncQuery(String annotationQuery) {
		158	String old = this.query;
		159	this.query = annotationQuery;
		160	this.firePropertyChanged(QUERY_PROPERTY, old, annotationQuery);
		161	}
		162
		163	private String buildQuery(Annotation astAnnotation) {
		164	return this.queryAdapter.getValue(astAnnotation);
		165	}
		166
		167	public List<TextRange> getQueryTextRanges() {
		168	return this.queryTextRanges;
		169	}
		170
		171	private List<TextRange> buildQueryTextRanges(Annotation astAnnotation) {
		172	return this.getElementTextRanges(this.queryDeclarationAdapter, astAnnotation);
		173	}
		174
		175	private DeclarationAnnotationElementAdapter<String> buildQueryDeclarationAdapter() {
		176	return ConversionDeclarationAnnotationElementAdapter.forStrings(this.daa, this.getQueryElementName());
		177	}
		178
		179	private AnnotationElementAdapter<String> buildQueryAdapter() {
		180	return this.buildStringElementAdapter(this.queryDeclarationAdapter);
		181	}
131		182
132	// ***** result class	183	// ***** result class
133	public String getResultClass() {	184	public String getResultClass() {
Lines 236-241 Link Here
236	@Override	287	@Override
237	public boolean isUnset() {	288	public boolean isUnset() {
238	return super.isUnset() &&	289	return super.isUnset() &&
		290	(this.query == null) &&
239	(this.resultClass == null) &&	291	(this.resultClass == null) &&
240	(this.resultSetMapping == null);	292	(this.resultSetMapping == null);
241	}	293	}

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/resource/java/source/SourceNamedQueryAnnotation.java (-6 / +80 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2011 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2013 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-21 Link Here
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.resource.java.source;	10	package org.eclipse.jpt.jpa.core.internal.resource.java.source;
11		11
		12	import java.util.List;
		13	import org.eclipse.jdt.core.dom.Annotation;
12	import org.eclipse.jpt.common.core.internal.utility.jdt.CombinationIndexedDeclarationAnnotationAdapter;	14	import org.eclipse.jpt.common.core.internal.utility.jdt.CombinationIndexedDeclarationAnnotationAdapter;
		15	import org.eclipse.jpt.common.core.internal.utility.jdt.ConversionDeclarationAnnotationElementAdapter;
13	import org.eclipse.jpt.common.core.internal.utility.jdt.ElementIndexedAnnotationAdapter;	16	import org.eclipse.jpt.common.core.internal.utility.jdt.ElementIndexedAnnotationAdapter;
14	import org.eclipse.jpt.common.core.internal.utility.jdt.SimpleDeclarationAnnotationAdapter;	17	import org.eclipse.jpt.common.core.internal.utility.jdt.SimpleDeclarationAnnotationAdapter;
15	import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;	18	import org.eclipse.jpt.common.core.resource.java.JavaResourceNode;
		19	import org.eclipse.jpt.common.core.utility.TextRange;
16	import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;	20	import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
17	import org.eclipse.jpt.common.core.utility.jdt.AnnotationAdapter;	21	import org.eclipse.jpt.common.core.utility.jdt.AnnotationAdapter;
		22	import org.eclipse.jpt.common.core.utility.jdt.AnnotationElementAdapter;
18	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;	23	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;
		24	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationElementAdapter;
19	import org.eclipse.jpt.common.core.utility.jdt.IndexedAnnotationAdapter;	25	import org.eclipse.jpt.common.core.utility.jdt.IndexedAnnotationAdapter;
20	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;	26	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;
21	import org.eclipse.jpt.jpa.core.resource.java.JPA;	27	import org.eclipse.jpt.jpa.core.resource.java.JPA;
Lines 32-70 Link Here
32	private static final DeclarationAnnotationAdapter DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(ANNOTATION_NAME);	38	private static final DeclarationAnnotationAdapter DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(ANNOTATION_NAME);
33	private static final DeclarationAnnotationAdapter CONTAINER_DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(JPA.NAMED_QUERIES);	39	private static final DeclarationAnnotationAdapter CONTAINER_DECLARATION_ANNOTATION_ADAPTER = new SimpleDeclarationAnnotationAdapter(JPA.NAMED_QUERIES);
34		40
		41	DeclarationAnnotationElementAdapter<String> queryDeclarationAdapter;
		42	AnnotationElementAdapter<String> queryAdapter;
		43	String query;
		44	List<TextRange> queryTextRanges;
35		45
36	protected SourceNamedQueryAnnotation(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter daa, AnnotationAdapter annotationAdapter) {	46	protected SourceNamedQueryAnnotation(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter daa, AnnotationAdapter annotationAdapter) {
37	super(parent, element, daa, annotationAdapter);	47	super(parent, element, daa, annotationAdapter);
		48	this.queryDeclarationAdapter = this.buildQueryDeclarationAdapter();
		49	this.queryAdapter = this.buildQueryAdapter();
38	}	50	}
39
40		51
41	public String getAnnotationName() {	52	public String getAnnotationName() {
42	return ANNOTATION_NAME;	53	return ANNOTATION_NAME;
43	}	54	}
44		55
		56	@Override
		57	public void initialize(Annotation astAnnotation) {
		58	super.initialize(astAnnotation);
		59
		60	this.query = this.buildQuery(astAnnotation);
		61	this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
		62	}
		63
		64	@Override
		65	public void synchronizeWith(Annotation astAnnotation) {
		66	super.synchronizeWith(astAnnotation);
		67
		68	this.syncQuery(this.buildQuery(astAnnotation));
		69	this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
		70	}
45		71
46	// ******** AbstractBaseNamedQueryAnnotation implementation ********	72	// ******** AbstractBaseNamedQueryAnnotation implementation ********
47		73
48	@Override	74	@Override
49	String getNameElementName() {	75	public String getNameElementName() {
50	return JPA.NAMED_QUERY__NAME;	76	return JPA.NAMED_QUERY__NAME;
51	}	77	}
52		78
53	@Override
54	String getQueryElementName() {	79	String getQueryElementName() {
55	return JPA.NAMED_QUERY__QUERY;	80	return JPA.NAMED_QUERY__QUERY;
56	}	81	}
57		82
58	@Override	83	@Override
59	String getHintsElementName() {	84	public String getHintsElementName() {
60	return JPA.NAMED_QUERY__HINTS;	85	return JPA.NAMED_QUERY__HINTS;
61	}	86	}
62		87
63	@Override	88	@Override
64	QueryHintAnnotation buildHint(int index) {	89	public QueryHintAnnotation buildHint(int index) {
65	return SourceQueryHintAnnotation.buildNamedQueryQueryHint(this, this.annotatedElement, this.daa, index);	90	return SourceQueryHintAnnotation.buildNamedQueryQueryHint(this, this.annotatedElement, this.daa, index);
66	}	91	}
67		92
		93	// ***** query
		94	public String getQuery() {
		95	return this.query;
		96	}
		97
		98	public void setQuery(String query) {
		99	if (this.attributeValueHasChanged(this.query, query)) {
		100	this.query = query;
		101	this.queryAdapter.setValue(query);
		102	}
		103	}
		104
		105	private void syncQuery(String annotationQuery) {
		106	String old = this.query;
		107	this.query = annotationQuery;
		108	this.firePropertyChanged(QUERY_PROPERTY, old, annotationQuery);
		109	}
		110
		111	private String buildQuery(Annotation astAnnotation) {
		112	return this.queryAdapter.getValue(astAnnotation);
		113	}
		114
		115	public List<TextRange> getQueryTextRanges() {
		116	return this.queryTextRanges;
		117	}
		118
		119	private List<TextRange> buildQueryTextRanges(Annotation astAnnotation) {
		120	return this.getElementTextRanges(this.queryDeclarationAdapter, astAnnotation);
		121	}
		122
		123	private DeclarationAnnotationElementAdapter<String> buildQueryDeclarationAdapter() {
		124	return ConversionDeclarationAnnotationElementAdapter.forStrings(this.daa, this.getQueryElementName());
		125	}
		126
		127	private AnnotationElementAdapter<String> buildQueryAdapter() {
		128	return this.buildStringElementAdapter(this.queryDeclarationAdapter);
		129	}
		130
		131	// ******** misc ********
		132
		133	@Override
		134	public boolean isUnset() {
		135	return super.isUnset() &&
		136	(this.query == null);
		137	}
		138
		139
		140	// ******** static methods ********
		141
68	protected static IndexedAnnotationAdapter buildNamedQueryAnnotationAdapter(AnnotatedElement annotatedElement, IndexedDeclarationAnnotationAdapter idaa) {	142	protected static IndexedAnnotationAdapter buildNamedQueryAnnotationAdapter(AnnotatedElement annotatedElement, IndexedDeclarationAnnotationAdapter idaa) {
69	return new ElementIndexedAnnotationAdapter(annotatedElement, idaa);	143	return new ElementIndexedAnnotationAdapter(annotatedElement, idaa);
70	}	144	}




/*******************************************************************************
 * Copyright (c) 2007, 2013 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.jpa.core.internal.resource.java.source;

import java.util.List;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jpt.common.core.internal.resource.java.source.SourceAnnotation;
import org.eclipse.jpt.common.core.internal.utility.jdt.ConversionDeclarationAnnotationElementAdapter;

 * <ul>
 * <li><code>javax.persistence.NamedQuery</code>
 * <li><code>javax.persistence.NamedNativeQuery</code>
 * <li><code>javax.persistence.NamedStoredProcedureQuery</code>
 * </ul>
 */
public abstract class SourceQueryAnnotation
	extends SourceAnnotation
	implements QueryAnnotation
{

	String name;
	TextRange nameTextRange;

	DeclarationAnnotationElementAdapter<String> queryDeclarationAdapter;
	AnnotationElementAdapter<String> queryAdapter;
	String query;
	List<TextRange> queryTextRanges;

	final QueryHintsAnnotationContainer hintsContainer = new QueryHintsAnnotationContainer();


	protected SourceQueryAnnotation(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter daa, AnnotationAdapter annotationAdapter) {
		super(parent, element, daa, annotationAdapter);
		this.nameDeclarationAdapter = this.buildNameDeclarationAdapter();
		this.nameAdapter = this.buildNameAdapter();

		this.queryAdapter = this.buildQueryAdapter();
	}

	@Override

		super.initialize(astAnnotation);
		this.name = this.buildName(astAnnotation);
		this.nameTextRange = this.buildNameTextRange(astAnnotation);
		this.query = this.buildQuery(astAnnotation);
		this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
		this.hintsContainer.initializeFromContainerAnnotation(astAnnotation);
	}


		super.synchronizeWith(astAnnotation);
		this.syncName(this.buildName(astAnnotation));
		this.nameTextRange = this.buildNameTextRange(astAnnotation);
		this.syncQuery(this.buildQuery(astAnnotation));
		this.queryTextRanges = this.buildQueryTextRanges(astAnnotation);
		this.hintsContainer.synchronize(astAnnotation);
	}


		return this.buildStringElementAdapter(this.nameDeclarationAdapter);
	}

	public abstract String getNameElementName();

	// ***** query
	public String getQuery() {
		return this.query;
	}

	public void setQuery(String query) {
		if (this.attributeValueHasChanged(this.query, query)) {
			this.query = query;
			this.queryAdapter.setValue(query);
		}
	}

	private void syncQuery(String annotationQuery) {
		String old = this.query;
		this.query = annotationQuery;
		this.firePropertyChanged(QUERY_PROPERTY, old, annotationQuery);
	}

	private String buildQuery(Annotation astAnnotation) {
		return this.queryAdapter.getValue(astAnnotation);
	}

	public List<TextRange> getQueryTextRanges() {
		return this.queryTextRanges;
	}

	private List<TextRange> buildQueryTextRanges(Annotation astAnnotation) {
		return this.getElementTextRanges(this.queryDeclarationAdapter, astAnnotation);
	}

	private DeclarationAnnotationElementAdapter<String> buildQueryDeclarationAdapter() {
		return ConversionDeclarationAnnotationElementAdapter.forStrings(this.daa, this.getQueryElementName());
	}

	private AnnotationElementAdapter<String> buildQueryAdapter() {
		return this.buildStringElementAdapter(this.queryDeclarationAdapter);
	}

	abstract String getQueryElementName();

	// ***** hints


		this.hintsContainer.removeNestedAnnotation(index);
	}

	public abstract QueryHintAnnotation buildHint(int index);

	public abstract String getHintsElementName();


	// ********** misc **********

	public boolean isUnset() {
		return super.isUnset() &&
				(this.name == null) &&
				(this.query == null) &&
				this.hintsContainer.isEmpty();
	}


Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/resource/java/source/SourceQueryHintAnnotation.java (-1 / +9 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2012 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2013 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 21-26 Link Here
21	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;	21	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationAdapter;
22	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationElementAdapter;	22	import org.eclipse.jpt.common.core.utility.jdt.DeclarationAnnotationElementAdapter;
23	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;	23	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;
		24	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
24	import org.eclipse.jpt.jpa.core.resource.java.JPA;	25	import org.eclipse.jpt.jpa.core.resource.java.JPA;
25	import org.eclipse.jpt.jpa.core.resource.java.QueryHintAnnotation;	26	import org.eclipse.jpt.jpa.core.resource.java.QueryHintAnnotation;
26		27
Lines 48-53 Link Here
48		49
49	static SourceQueryHintAnnotation buildNamedNativeQueryQueryHint(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter namedNativeQueryAdapter, int index) {	50	static SourceQueryHintAnnotation buildNamedNativeQueryQueryHint(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter namedNativeQueryAdapter, int index) {
50	return buildNestedSourceQueryHintAnnotation(parent, element, buildNamedNativeQueryQueryHintAnnotationAdapter(namedNativeQueryAdapter, index));	51	return buildNestedSourceQueryHintAnnotation(parent, element, buildNamedNativeQueryQueryHintAnnotationAdapter(namedNativeQueryAdapter, index));
		52	}
		53
		54	public static SourceQueryHintAnnotation buildNamedStoredProcedureQuery2_1QueryHint(JavaResourceNode parent, AnnotatedElement element, DeclarationAnnotationAdapter namedStoredProcedureQuery2_1Adapter, int index) {
		55	return buildNestedSourceQueryHintAnnotation(parent, element, buildNamedStoredProcedureQuery2_1QueryHintAnnotationAdapter(namedStoredProcedureQuery2_1Adapter, index));
51	}	56	}
52		57
53	public static SourceQueryHintAnnotation buildNestedSourceQueryHintAnnotation(	58	public static SourceQueryHintAnnotation buildNestedSourceQueryHintAnnotation(
Lines 193-196 Link Here
193	private static IndexedDeclarationAnnotationAdapter buildNamedNativeQueryQueryHintAnnotationAdapter(DeclarationAnnotationAdapter namedNativeQueryAdapter, int index) {	198	private static IndexedDeclarationAnnotationAdapter buildNamedNativeQueryQueryHintAnnotationAdapter(DeclarationAnnotationAdapter namedNativeQueryAdapter, int index) {
194	return new NestedIndexedDeclarationAnnotationAdapter(namedNativeQueryAdapter, JPA.NAMED_NATIVE_QUERY__HINTS, index, ANNOTATION_NAME);	199	return new NestedIndexedDeclarationAnnotationAdapter(namedNativeQueryAdapter, JPA.NAMED_NATIVE_QUERY__HINTS, index, ANNOTATION_NAME);
195	}	200	}
		201	private static IndexedDeclarationAnnotationAdapter buildNamedStoredProcedureQuery2_1QueryHintAnnotationAdapter(DeclarationAnnotationAdapter namedStoredProcedureQuery2_1Adapter, int index) {
		202	return new NestedIndexedDeclarationAnnotationAdapter(namedStoredProcedureQuery2_1Adapter, JPA2_1.NAMED_STORED_PROCEDURE_QUERY__HINTS, index, ANNOTATION_NAME);
		203	}
196	}	204	}




/*******************************************************************************
 * Copyright (c) 2012 2013 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.

	// JPA 2.1 annotations
	String CONVERTER = PACKAGE_ + "Converter";
		String CONVERTER__AUTO_APPLY = "autoApply";
		
	String NAMED_STORED_PROCEDURE_QUERIES = PACKAGE_ + "NamedStoredProcedureQueries";
		String NAMED_STORED_PROCEDURE_QUERIES__VALUE = "value";
	String NAMED_STORED_PROCEDURE_QUERY =PACKAGE_ + "NamedStoredProcedureQuery";
		String NAMED_STORED_PROCEDURE_QUERY__NAME = "name";
		String NAMED_STORED_PROCEDURE_QUERY__PROCEDURE_NAME= "procedureName";
		String NAMED_STORED_PROCEDURE_QUERY__PARAMETERS = "parameters";
		String NAMED_STORED_PROCEDURE_QUERY__RESULT_CLASSES = "resultClasses";
		String NAMED_STORED_PROCEDURE_QUERY__RESULT_SET_MAPPINGS= "resultSetMappings";
		String NAMED_STORED_PROCEDURE_QUERY__HINTS = "hints";
	String NAMED_STORED_PROCEDURE_PARAMETER = PACKAGE_ + "StoredProcedureParameter";
		String NAMED_STORED_PROCEDURE_PARAMETER__NAME = "name";
		String NAMED_STORED_PROCEDURE_PARAMETER__MODE = "mode";
		String NAMED_STORED_PROCEDURE_PARAMETER__TYPE = "type";
		
	// JPA 2.1 enums
	String PARAMETER_MODE = PACKAGE_ + "ParameterMode";
		String PARAMETER_MODE_ = PARAMETER_MODE + '.';
		String PARAMETER_MODE__IN = PARAMETER_MODE_ + "IN";
		String PARAMETER_MODE__INOUT = PARAMETER_MODE_ + "INOUT";
		String PARAMETER_MODE__OUT = PARAMETER_MODE_ + "OUT";
		String PARAMETER_MODE__REF_CURSOR= PARAMETER_MODE_ + "REF_CURSOR";

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java;

import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.resource.java.QueryAnnotation;

/**
 * Corresponds to the JPA annotation
 * <code>javax.persistence.NamedStoredProcedureQuery</code>
 * <p>
 * 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
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 3.3
 * @since 3.3
 */
public interface NamedStoredProcedureQuery2_1Annoation
	extends QueryAnnotation
{
	String ANNOTATION_NAME = JPA2_1.NAMED_STORED_PROCEDURE_QUERY;


	// ********** procedure name **********

	/**
	 * Corresponds to the 'procedureName' element of the *NamedStoredProcedureQuery annotation.
	 * Return null if the element does not exist in Java.
	 */
	String getProcedureName();
		String PROCEDURE_NAME_PROPERTY = "procedureName"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'procedureName' element of the *NamedStoredProcedureQuery annotation.
	 * Set to null to remove the element.
	 */
	void setProcedureName(String procedureName);

	/**
	 * Return the {@link TextRange} for the 'procedureName' element. If element
	 * does not exist return the {@link TextRange} for the *NamedStoredProcedureQuery annotation.
	 */
	TextRange getProcedureNameTextRange();


	// ********** parameters **********

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 * Return an empty iterator if the element does not exist in Java.
	 */
	ListIterable<StoredProcedureParameter2_1Annotation> getParameters();
		String PARAMETERS_LIST = "parameters"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 */
	int getParametersSize();

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 */
	StoredProcedureParameter2_1Annotation parameterAt(int index);

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 */
	StoredProcedureParameter2_1Annotation addParameter(int index);

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 */
	void moveParameter(int targetIndex, int sourceIndex);

	/**
	 * Corresponds to the 'parameters' element of the *NamedStoredProcedureQuery annotation.
	 */
	void removeParameter(int index);


	// ********** result classes **********

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 * Return an empty iterator if the element does not exist in Java.
	 */
	ListIterable<String> getResultClasses();
		String RESULT_CLASSES_LIST = "resultClasses"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	int getResultClassesSize();

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	String resultClassAt(int index);

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	void addResultClass(String resultClass);

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	void moveResultClass(int targetIndex, int sourceIndex);

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	void removeResultClass(String resultClass);

	/**
	 * Corresponds to the 'resultClasses' element of the *NamedStoredProcedureQuery annotation.
	 */
	void removeResultClass(int index);

	
	// ********** result set mappings **********

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 * Return an empty iterator if the element does not exist in Java.
	 */
	ListIterable<String> getResultSetMappings();
		String RESULT_SET_MAPPINGS_LIST = "resultSetMappings"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	int getResultSetMappingsSize();

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	String resultSetMappingAt(int index);

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	void addResultSetMapping(String resultSetMapping);

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	void moveResultSetMapping(int targetIndex, int sourceIndex);

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	void removeResultSetMapping(String resultSetMapping);

	/**
	 * Corresponds to the 'resultSetMappings' element of the *NamedStoredProcedureQuery annotation.
	 */
	void removeResultSetMapping(int index);

}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java;


/**
 * Corresponds to the JPA 2.1 enum
 * javax.persistence.ParameterMode
 * <p>
 * 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
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 3.3
 * @since 3.3
 */
public enum ParameterMode2_1
{
	
	IN(JPA2_1.PARAMETER_MODE__IN),
	INOUT(JPA2_1.PARAMETER_MODE__INOUT),
	OUT(JPA2_1.PARAMETER_MODE__OUT),
	REF_CURSOR(JPA2_1.PARAMETER_MODE__REF_CURSOR);


	private String javaAnnotationValue;

	ParameterMode2_1(String javaAnnotationValue) {
		if (javaAnnotationValue == null) {
			throw new NullPointerException();
		}
		this.javaAnnotationValue = javaAnnotationValue;
	}

	public String getJavaAnnotationValue() {
		return this.javaAnnotationValue;
	}


	// ********** static methods **********

	public static ParameterMode2_1 fromJavaAnnotationValue(Object javaAnnotationValue) {
		return (javaAnnotationValue == null) ? null : fromJavaAnnotationValue_(javaAnnotationValue);
	}

	private static ParameterMode2_1 fromJavaAnnotationValue_(Object javaAnnotationValue) {
		for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) {
			if (parameterMode.getJavaAnnotationValue().equals(javaAnnotationValue)) {
				return parameterMode;
			}
		}
		return null;
	}

	public static String toJavaAnnotationValue(ParameterMode2_1 parameterMode) {
		return (parameterMode == null) ? null : parameterMode.getJavaAnnotationValue();
	}
}




/*******************************************************************************
 * Copyright (c) 2013 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.jpa2_1.resource.java;

import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.core.utility.TextRange;

/**
 * Corresponds to the JPA annotation
 * <code>javax.persistence.StoredProcedureParameter</code>
 * <p>
 * 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
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 3.3
 * @since 3.3
 */
public interface StoredProcedureParameter2_1Annotation
	extends NestableAnnotation
{
	String ANNOTATION_NAME = JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER;

	// ********* name **********
	/**
	 * Corresponds to the 'name' element of the StoredProcedureParameter annotation.
	 * Return null if the element does not exist in the annotation
	 */
	String getName();
		String NAME_PROPERTY = "name"; //$NON-NLS-1$
	
	/**
	 * Corresponds to the 'name' element of the StoredProcedureParameter annotation.
	 * Setting to null will remove the element.
	 */
	void setName(String name);
		
	/**
	 * Return the {@link TextRange} for the 'name' element. If the element 
	 * does not exist return the {@link TextRange} for the StoredProcedureParameter annotation.
	 */
	TextRange getNameTextRange();

	// *********** mode *************

	/**
	 * Corresponds to the 'mode' element of the StoredProcedureParameter annotation.
	 * Return null if the element does not exist in the annotation
	 */
	ParameterMode2_1 getMode();
		String MODE_PROPERTY = "mode"; //$NON-NLS-1$
	
	/**
	 * Corresponds to the 'mode' element of the StoredProcedureParameter annotation.
	 * Setting to null will remove the element.
	 */
	void setMode(ParameterMode2_1 mode);

	/**
	 * Return the {@link TextRange} for the 'mode' element. If the element 
	 * does not exist return the {@link TextRange} for the StoredProcedureParameter annotation.
	 */
	TextRange getModeTextRange();
	
	// ********** type ***********

	/**
	 * Corresponds to the 'type' element of the StoredProcedureParameter annotation.
	 * Return null if the element does not exist in the annotation
	 */
	String getType();
		String TYPE_PROPERTY = "type"; //$NON-NLS-1$
	
	/**
	 * Corresponds to the 'type' element of the StoredProcedureParameter annotation.
	 * Setting to null will remove the element.
	 */
	void setType(String type);

	/**
	 * Return the {@link TextRange} for the 'type' element. If the element 
	 * does not exist return the {@link TextRange} for the StoredProcedureParameter annotation.
	 */
	TextRange getTypeTextRange();

	/**
	 * Return the named native query's fully-qualified type name as
	 * resolved by the AST's bindings.
	 * <pre>
	 *     &#64;NamedStoredProcedureQuery(type=Employee.class)
	 * </pre>
	 * will return <code>"model.Employee"</code> if there is an import for
	 * <code>model.Employee</code>.
	 */
	String getFullyQualifiedTypeName();
}




/*******************************************************************************
 * Copyright (c) 2007, 2013 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.jpa.core.resource.java;

import java.util.List;
import org.eclipse.jpt.common.core.utility.TextRange;



	String ANNOTATION_NAME = JPA.NAMED_NATIVE_QUERY;


	// ********** query **********

	/**
	 * Corresponds to the 'query' element of the *Query annotation.
	 * Return null if the element does not exist in Java.
	 */
	String getQuery();
		String QUERY_PROPERTY = "query"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'query' element of the *Query annotation.
	 * Set to null to remove the element.
	 */
	void setQuery(String query);

	/**
	 * Return the {@link TextRange} for the 'query' element. If element
	 * does not exist return the {@link TextRange} for the *Query annotation.
	 */
	List<TextRange> getQueryTextRanges();


	// ********** result class **********

	/**

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/resource/java/NamedQueryAnnotation.java (-1 / +26 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Oracle. All rights reserved.	2	* Copyright (c) 2007, 2013 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 8-13 Link Here
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.resource.java;	10	package org.eclipse.jpt.jpa.core.resource.java;
		11
		12	import java.util.List;
		13	import org.eclipse.jpt.common.core.utility.TextRange;
11		14
12	/**	15	/**
13	* Corresponds to the JPA annotation	16	* Corresponds to the JPA annotation
Lines 26-29 Link Here
26	extends QueryAnnotation	29	extends QueryAnnotation
27	{	30	{
28	String ANNOTATION_NAME = JPA.NAMED_QUERY;	31	String ANNOTATION_NAME = JPA.NAMED_QUERY;
		32
		33	// ******** query ********
		34
		35	/**
		36	* Corresponds to the 'query' element of the *Query annotation.
		37	* Return null if the element does not exist in Java.
		38	*/
		39	String getQuery();
		40	String QUERY_PROPERTY = "query"; //$NON-NLS-1$
		41
		42	/**
		43	* Corresponds to the 'query' element of the *Query annotation.
		44	* Set to null to remove the element.
		45	*/
		46	void setQuery(String query);
		47
		48	/**
		49	* Return the {@link TextRange} for the 'query' element. If element
		50	* does not exist return the {@link TextRange} for the *Query annotation.
		51	*/
		52	List<TextRange> getQueryTextRanges();
		53
29	}	54	}




/*******************************************************************************
 * Copyright (c) 2007, 2013 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.jpa.core.resource.java;

import java.util.List;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.iterable.ListIterable;

	 * does not exist return the {@link TextRange} for the *Query annotation.
	 */
	TextRange getNameTextRange();


	// ********** query **********

	/**
	 * Corresponds to the 'query' element of the *Query annotation.
	 * Return null if the element does not exist in Java.
	 */
	String getQuery();
		String QUERY_PROPERTY = "query"; //$NON-NLS-1$

	/**
	 * Corresponds to the 'query' element of the *Query annotation.
	 * Set to null to remove the element.
	 */
	void setQuery(String query);

	/**
	 * Return the {@link TextRange} for the 'query' element. If element
	 * does not exist return the {@link TextRange} for the *Query annotation.
	 */
	List<TextRange> getQueryTextRanges();


	// ********** hints **********




import org.eclipse.jpt.common.ui.internal.widgets.ClassChooserPane;
import org.eclipse.jpt.common.ui.internal.widgets.Pane;
import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;
import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.common.utility.model.value.ModifiablePropertyValueModel;
import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;
import org.eclipse.jpt.jpa.core.context.Query;
import org.eclipse.swt.SWT;

	}

	private ModifiablePropertyValueModel<String> buildQueryHolder() {
		return new PropertyAspectAdapter<NamedNativeQuery, String>(getSubjectHolder(), NamedNativeQuery.QUERY_PROPERTY) {
			@Override
			protected String buildValue_() {
				return this.subject.getQuery();

Lines 83-89 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/details/NamedQueryPropertyComposite.java (-1 / +1 lines)
83	}	83	}
84		84
85	protected ModifiablePropertyValueModel<String> buildQueryHolder() {	85	protected ModifiablePropertyValueModel<String> buildQueryHolder() {
86	return new PropertyAspectAdapter<NamedQuery, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {	86	return new PropertyAspectAdapter<NamedQuery, String>(getSubjectHolder(), NamedQuery.QUERY_PROPERTY) {
87	@Override	87	@Override
88	protected String buildValue_() {	88	protected String buildValue_() {
89	return this.subject.getQuery();	89	return this.subject.getQuery();

Lines 16-21 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/jpa2/details/NamedQueryProperty2_0Composite.java (-1 / +2 lines)
16	import org.eclipse.jpt.common.utility.model.value.ModifiablePropertyValueModel;	16	import org.eclipse.jpt.common.utility.model.value.ModifiablePropertyValueModel;
17	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;	17	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
18	import org.eclipse.jpt.jpa.core.JpaPreferences;	18	import org.eclipse.jpt.jpa.core.JpaPreferences;
		19	import org.eclipse.jpt.jpa.core.context.NamedQuery;
19	import org.eclipse.jpt.jpa.core.context.Query;	20	import org.eclipse.jpt.jpa.core.context.Query;
20	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;	21	import org.eclipse.jpt.jpa.core.jpa2.context.LockModeType2_0;
21	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;	22	import org.eclipse.jpt.jpa.core.jpa2.context.NamedQuery2_0;
Lines 91-97 Link Here
91	}	92	}
92		93
93	protected ModifiablePropertyValueModel<String> buildQueryHolder() {	94	protected ModifiablePropertyValueModel<String> buildQueryHolder() {
94	return new PropertyAspectAdapter<NamedQuery2_0, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {	95	return new PropertyAspectAdapter<NamedQuery2_0, String>(getSubjectHolder(), NamedQuery.QUERY_PROPERTY) {
95	@Override	96	@Override
96	protected String buildValue_() {	97	protected String buildValue_() {
97	return this.subject.getQuery();	98	return this.subject.getQuery();




/*******************************************************************************
 * Copyright (c) 2013 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.tests.internal.jpa2_1.resource.java;

import junit.framework.Test;
import junit.framework.TestSuite;

public class JavaResource2_1Tests
{

	public static Test suite() {
		TestSuite suite = new TestSuite(JavaResource2_1Tests.class.getPackage().getName());
		
		suite.addTestSuite(NamedStoredProcedureQuery2_1AnnoationTests.class);
		suite.addTestSuite(NamedStoredProcedureQueries2_1AnnotationTests.class);
		suite.addTestSuite(StoredProcedureParameter2_1AnnotationTests.class);
			
		return suite;
	}

	private JavaResource2_1Tests() {
		super();
		throw new UnsupportedOperationException();
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.tests.internal.jpa2_1.resource.java;

import org.eclipse.jpt.common.core.AnnotationProvider;
import org.eclipse.jpt.jpa.core.internal.JpaAnnotationProvider;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.Generic2_1JpaAnnotationDefinitionProvider;
import org.eclipse.jpt.jpa.core.tests.internal.resource.java.JpaJavaResourceModelTestCase;

public class JavaResourceModel2_1TestCase
	extends JpaJavaResourceModelTestCase
{
	
	
	public JavaResourceModel2_1TestCase(String name) {
		super(name);
	}

	@Override
	protected AnnotationProvider buildAnnotationProvider() {
		return new JpaAnnotationProvider(
			Generic2_1JpaAnnotationDefinitionProvider.instance());
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.tests.internal.jpa2_1.resource.java;

import java.util.Iterator;
import java.util.ListIterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.utility.internal.iterator.ArrayIterator;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annoation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
import org.eclipse.jpt.jpa.core.resource.java.JPA;
import org.eclipse.jpt.jpa.core.resource.java.QueryHintAnnotation;

public class NamedStoredProcedureQueries2_1AnnotationTests
	extends JavaResourceModel2_1TestCase
{

	private static final String QUERY_NAME = "myQuery";
	private static final String QUERY_PROCEDURE_NAME = "myProcedure";
	
	public NamedStoredProcedureQueries2_1AnnotationTests(String name) {
		super(name);
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueries() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery)");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithName() throws Exception {
		return createTestQueryWithStringElement("name", QUERY_NAME);
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithProcedureName() throws Exception {
		return createTestQueryWithStringElement("procedureName", QUERY_PROCEDURE_NAME);
	}
	
	private ICompilationUnit createTestQueryWithStringElement(final String elementName, final String value) throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery(" + elementName + " = \"" + value + "\"))");
			}
		});
	}

	private ICompilationUnit createTestNamedStoredProcedureQueryWithParameters() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER, JPA2_1.PARAMETER_MODE);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"BAR\", " +
						"mode=ParameterMode.IN, type=Integer.class), @StoredProcedureParameter}))");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithResultClasses() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery(resultClasses={Employee.class, Address.class})");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithResultSetMappings() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery(resultSetMappings={\"EmployeeResultSetMapping\", \"AddressResultSetMapping\"})");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithHints() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES, JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA.QUERY_HINT);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQueries(@NamedStoredProcedureQuery(hints = {@QueryHint(name = \"BAR\", value = \"FOO\"), @QueryHint}))");
			}
		});
	}

	private ICompilationUnit createTestNamedStoredProcedureQuery() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA.QUERY_HINT);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\"))");
			}
		});
	}

	public void testNamedStoredProcedureQuery() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueries();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertNotNull(namedQuery);
	}

	// ******** name *********
	
	public void testGetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_NAME, namedQuery.getName());
	}

	public void testSetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_NAME, namedQuery.getName());
		
		namedQuery.setName("foo");
		assertEquals("foo", namedQuery.getName());
		
		assertSourceContains("@NamedStoredProcedureQuery(name = \"foo\")", cu);
		
		namedQuery.setName(null);
		assertNull(namedQuery.getName());
		
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}

	// ********** procedure name ************
	
	public void testGetProcedureName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithProcedureName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_PROCEDURE_NAME, namedQuery.getProcedureName());
	}

	public void testSetProcedureName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithProcedureName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_PROCEDURE_NAME, namedQuery.getProcedureName());
		
		namedQuery.setProcedureName("foo");
		assertEquals("foo", namedQuery.getProcedureName());
		
		assertSourceContains("@NamedStoredProcedureQuery(procedureName = \"foo\")", cu);
		
		namedQuery.setProcedureName(null);
		assertNull(namedQuery.getProcedureName());
		
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}

	// *********** parameters *********
	
	public void testParameters1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueries();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getParametersSize());
	}
	
	public void testParameters2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getParametersSize());
		
		ListIterator<StoredProcedureParameter2_1Annotation> iterator = namedQuery.getParameters().iterator();
		assertEquals("BAR", iterator.next().getName());
		assertNull(iterator.next().getName());
	}

	// *********** result classes *******
	
	public void testResultClasses1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueries();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getResultClassesSize());
	}
	
	public void testResultClasses2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getResultClassesSize());
		
		ListIterator<String> iterator = namedQuery.getResultClasses().iterator();
		assertEquals("Employee", iterator.next());
		assertEquals("Address", iterator.next());
	
	}
	
	// ********** result set mappings ********
	
	public void testResultSetMappings1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueries();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getResultSetMappingsSize());
	}
	
	public void testResultSetMappings2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getResultSetMappingsSize());
		
		ListIterator<String> iterator = namedQuery.getResultSetMappings().iterator();
		assertEquals("EmployeeResultSetMapping", iterator.next());
		assertEquals("AddressResultSetMapping", iterator.next());
	
	}

	// *********** hints ********
	
	public void testHints1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueries();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getHintsSize());
	}
	
	public void testHints2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithHints();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getHintsSize());
		
		ListIterator<QueryHintAnnotation> iterator = namedQuery.getHints().iterator();
		assertEquals("BAR", iterator.next().getName());
		assertNull(iterator.next().getName());
	}
	
	// ********** other tests ********
	
	public void testAddNamedQueryCopyExisting() throws Exception {
		ICompilationUnit cu = createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		String expected1 = "@NamedStoredProcedureQueries({";
		String expected2 = "@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\")),";
		String expected3 = "@NamedStoredProcedureQuery(name = \"BAR\") })";
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.addAnnotation(1, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.setName("BAR");
		assertSourceContains(expected1, cu);
		assertSourceContains(expected2, cu);
		assertSourceContains(expected3, cu);
		
		assertNull(resourceType.getAnnotation(JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
		assertNotNull(resourceType.getContainerAnnotation(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES));
		assertNotNull(resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
		assertEquals(2, resourceType.getAnnotationsSize(JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
	}
	
	public void testAddNamedQueryToBeginningOfList() throws Exception {
		ICompilationUnit cu = createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		String expected1 = "@NamedStoredProcedureQueries({";
		String expected2 = "@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\")),";
		String expected3 = "@NamedStoredProcedureQuery(name = \"BAR\") })";
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.addAnnotation(1, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.setName("BAR");
		assertSourceContains(expected1, cu);
		assertSourceContains(expected2, cu);
		assertSourceContains(expected3, cu);
		
		expected2 = "@NamedStoredProcedureQuery(name = \"BAZ\"),";
		expected3 = "@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\")), @NamedStoredProcedureQuery(name = \"BAR\") })";
		namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.addAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.setName("BAZ");
		assertSourceContains(expected1, cu);
		assertSourceContains(expected2, cu);
		assertSourceContains(expected3, cu);

		Iterator<NestableAnnotation> namedQueries = resourceType.getAnnotations(JPA2_1.NAMED_STORED_PROCEDURE_QUERY).iterator();
		assertEquals("BAZ", ((NamedStoredProcedureQuery2_1Annoation) namedQueries.next()).getName());
		assertEquals("foo", ((NamedStoredProcedureQuery2_1Annoation) namedQueries.next()).getName());
		assertEquals("BAR", ((NamedStoredProcedureQuery2_1Annoation) namedQueries.next()).getName());

		assertNull(resourceType.getAnnotation(JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
		assertNotNull(resourceType.getContainerAnnotation(JPA2_1.NAMED_STORED_PROCEDURE_QUERIES));
		assertNotNull(resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
		assertEquals(3, resourceType.getAnnotationsSize(JPA2_1.NAMED_STORED_PROCEDURE_QUERY));
	}

	public void testRemoveNamedQueryCopyExisting() throws Exception {
		ICompilationUnit cu = createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		String expected1 = "@NamedStoredProcedureQueries({";
		String expected2 = "@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\")),";
		String expected3 = "@NamedStoredProcedureQuery(name = \"BAR\") })";
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.addAnnotation(1, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.setName("BAR");
		assertSourceContains(expected1, cu);
		assertSourceContains(expected2, cu);
		assertSourceContains(expected3, cu);
		
		expected1 = "@NamedStoredProcedureQuery(name = \"foo\", hints = @QueryHint(name = \"BAR\", value = \"FOO\"))";
		resourceType.removeAnnotation(1, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertSourceContains(expected1, cu);
		assertSourceDoesNotContain("@NamedStoredProcedureQueries", cu);
	}

}




/*******************************************************************************
 * Copyright (c) 2013 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.tests.internal.jpa2_1.resource.java;

import java.util.Iterator;
import java.util.ListIterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.utility.internal.iterator.ArrayIterator;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annoation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
import org.eclipse.jpt.jpa.core.resource.java.JPA;
import org.eclipse.jpt.jpa.core.resource.java.QueryHintAnnotation;

public class NamedStoredProcedureQuery2_1AnnoationTests
	extends JavaResourceModel2_1TestCase
{

	private static final String QUERY_NAME = "myQuery";
	private static final String PROCEDURE_NAME = "myProcedure";

	public NamedStoredProcedureQuery2_1AnnoationTests(String name) {
		super(name);
		}
	
	private ICompilationUnit createTestNamedStoredProcedureQuery() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithName() throws Exception {
		return createTestNamedStoredProcedureQueryWithStringElement("name", QUERY_NAME);
	}
	
	private ICompilationUnit createTestNamedNativeQueryWithProcedureName() throws Exception {
		return createTestNamedStoredProcedureQueryWithStringElement("procedureName", PROCEDURE_NAME);
	}
	

	private ICompilationUnit createTestNamedStoredProcedureQueryWithStringElement(final String elementName, final String value) throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(" + elementName + " = \"" + value + "\")");
			}
		});
	}

	private ICompilationUnit createTestNamedStoredProcedureQueryWithParameters() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER, JPA2_1.PARAMETER_MODE);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"BAR\", " +
						"mode=ParameterMode.IN, type=Integer.class), @StoredProcedureParameter})");
			}
		});
	}

	private ICompilationUnit createTestNamedStoredProcedureQueryWithResultClasses() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(resultClasses = { Employee.class, Address.class })");
			}
		});
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithResultSetMappings() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(resultSetMappings = { \"EmpRSMapping\", \"AddrRSMapping\" })");
			}
		});
	}

	private ICompilationUnit createTestNamedStoredProcedureQueryWithHints() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA.QUERY_HINT);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(hints = {@QueryHint(name = \"BAR\", value = \"FOO\"), @QueryHint})");
			}
		});
	}

	public void testNamedStoredProcedureQuery() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertNotNull(namedQuery);
	}

	// ************ name ***********
	
	public void testGetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_NAME, namedQuery.getName());
	}

	public void testSetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(QUERY_NAME, namedQuery.getName());
		
		namedQuery.setName("foo");
		assertEquals("foo", namedQuery.getName());
		
		assertSourceContains("@NamedStoredProcedureQuery(name = \"foo\")", cu);
		
		namedQuery.setName(null);
		assertNull(namedQuery.getName());
		
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}

	// ************ procedure name ***************
	
	public void testGetProcedureName() throws Exception {
		ICompilationUnit cu = this.createTestNamedNativeQueryWithProcedureName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(PROCEDURE_NAME, namedQuery.getProcedureName());
	}

	public void testSetProcedureName() throws Exception {
		ICompilationUnit cu = this.createTestNamedNativeQueryWithProcedureName();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(PROCEDURE_NAME, namedQuery.getProcedureName());
		
		namedQuery.setProcedureName("foo");
		assertEquals("foo", namedQuery.getProcedureName());
		
		assertSourceContains("@NamedStoredProcedureQuery(procedureName = \"foo\")", cu);
		
		namedQuery.setProcedureName(null);
		assertNull(namedQuery.getProcedureName());
		
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	// ************ parameters *********
	
	public void testParameters1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getParametersSize());
	}
	
	public void testParameters2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addParameter(0);
		namedQuery.addParameter(1);
		
		assertEquals(2, namedQuery.getParametersSize());
	}
	
	public void testParameters3() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getParametersSize());
		
		ListIterator<StoredProcedureParameter2_1Annotation> iterator = namedQuery.getParameters().iterator();
		assertEquals("BAR", iterator.next().getName());
		assertNull(iterator.next().getName());
	}
	
	public void testAddParameter() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addParameter(0).setName("FOO");
		namedQuery.addParameter(1);
		namedQuery.addParameter(0).setName("BAR");

		assertEquals("BAR", namedQuery.parameterAt(0).getName());
		assertEquals("FOO", namedQuery.parameterAt(1).getName());
		assertNull(namedQuery.parameterAt(2).getName());
		assertSourceContains("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"BAR\")," +
				"@StoredProcedureParameter(name = \"FOO\"), @StoredProcedureParameter})", cu);
	}
	
	public void testRemoveParameter() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);

		namedQuery.addParameter(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.parameterAt(0).getName());
		assertEquals("BAR", namedQuery.parameterAt(1).getName());
		assertNull(namedQuery.parameterAt(2).getName());
		assertEquals(3, namedQuery.getParametersSize());
		
		namedQuery.removeParameter(2);
		assertEquals("BAZ", namedQuery.parameterAt(0).getName());
		assertEquals("BAR", namedQuery.parameterAt(1).getName());
		assertEquals(2, namedQuery.getParametersSize());
		assertSourceContains("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"BAZ\"), " +
				"@StoredProcedureParameter(name = \"BAR\", mode=ParameterMode.IN, type=Integer.class)})", cu);
		
		namedQuery.removeParameter(0);
		assertEquals("BAR", namedQuery.parameterAt(0).getName());
		assertEquals(1, namedQuery.getParametersSize());
		assertSourceContains("@NamedStoredProcedureQuery(parameters = " +
				"@StoredProcedureParameter(name = \"BAR\", mode=ParameterMode.IN, type=Integer.class))", cu);
		
		namedQuery.removeParameter(0);
		assertEquals(0, namedQuery.getParametersSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	public void testMoveParameter1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addParameter(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.parameterAt(0).getName());
		assertEquals("BAR", namedQuery.parameterAt(1).getName());
		assertNull(namedQuery.parameterAt(2).getName());
		assertEquals(3, namedQuery.getParametersSize());
	
		namedQuery.moveParameter(2, 0);
		
		assertEquals("BAR", namedQuery.parameterAt(0).getName());
		assertNull(namedQuery.parameterAt(1).getName());
		assertEquals("BAZ", namedQuery.parameterAt(2).getName());
		assertEquals(3, namedQuery.getParametersSize());
		assertSourceContains("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"BAR\", mode=ParameterMode.IN, type=Integer.class), " +
				"@StoredProcedureParameter, @StoredProcedureParameter(name = \"BAZ\")})", cu);
	}
	
	public void testMoveParameter2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.addParameter(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.parameterAt(0).getName());
		assertEquals("BAR", namedQuery.parameterAt(1).getName());
		assertNull(namedQuery.parameterAt(2).getName());
		assertEquals(3, namedQuery.getParametersSize());
	
		namedQuery.moveParameter(0, 2);
		
		assertNull(namedQuery.parameterAt(0).getName());
		assertEquals("BAZ", namedQuery.parameterAt(1).getName());
		assertEquals("BAR", namedQuery.parameterAt(2).getName());
		assertEquals(3, namedQuery.getParametersSize());
		assertSourceContains("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter, @StoredProcedureParameter(name = \"BAZ\"), " +
				"@StoredProcedureParameter(name = \"BAR\", mode=ParameterMode.IN, type=Integer.class)})", cu);
	}
	
	// ************ result classes *********
	
	public void testResultClasses1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getResultClassesSize());
	}
	
	public void testResultClasses2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getResultClassesSize());
		
		ListIterator<String> iterator = namedQuery.getResultClasses().iterator();
		assertEquals("Employee", iterator.next());
		assertEquals("Address", iterator.next());
	}
	
	public void testAddResultClass() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultClass("Project");
		namedQuery.addResultClass("Phone");
		
		assertEquals(2, namedQuery.getResultClassesSize());

		assertEquals("Project", namedQuery.resultClassAt(0));
		assertEquals("Phone", namedQuery.resultClassAt(1));
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = { Project.class, Phone.class })", cu);
	}
	
	public void testRemoveResultClass1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);

		namedQuery.addResultClass("Project");
		
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Address", namedQuery.resultClassAt(1));
		assertEquals("Project", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
		
		namedQuery.removeResultClass(1);
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Project", namedQuery.resultClassAt(1));
		assertEquals(2, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = { Employee.class, Project.class })", cu);
		
		namedQuery.removeResultClass(0);
		assertEquals("Project", namedQuery.resultClassAt(0));
		assertEquals(1, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = Project.class)", cu);
		
		namedQuery.removeResultClass(0);
		assertEquals(0, namedQuery.getResultClassesSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	public void testRemoveResultClass2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);

		namedQuery.addResultClass("Project");
		
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Address", namedQuery.resultClassAt(1));
		assertEquals("Project", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
		
		namedQuery.removeResultClass("Address");
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Project", namedQuery.resultClassAt(1));
		assertEquals(2, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = { Employee.class, Project.class })", cu);
		
		namedQuery.removeResultClass("Employee");
		assertEquals("Project", namedQuery.resultClassAt(0));
		assertEquals(1, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = Project.class)", cu);
		
		namedQuery.removeResultClass("Project");
		assertEquals(0, namedQuery.getResultClassesSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	public void testMoveResultClass1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultClass("Project");
		
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Address", namedQuery.resultClassAt(1));
		assertEquals("Project", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
	
		namedQuery.moveResultClass(2, 0);
		
		assertEquals("Address", namedQuery.resultClassAt(0));
		assertEquals("Project", namedQuery.resultClassAt(1));
		assertEquals("Employee", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = { Address.class, Project.class, Employee.class })", cu);
	}
	
	public void testMoveResultClass2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultClasses();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.addResultClass("Project");
		
		assertEquals("Employee", namedQuery.resultClassAt(0));
		assertEquals("Address", namedQuery.resultClassAt(1));
		assertEquals("Project", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
	
		namedQuery.moveResultClass(0, 2);
		
		assertEquals("Project", namedQuery.resultClassAt(0));
		assertEquals("Employee", namedQuery.resultClassAt(1));
		assertEquals("Address", namedQuery.resultClassAt(2));
		assertEquals(3, namedQuery.getResultClassesSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultClasses = { Project.class, Employee.class, Address.class })", cu);
	}
	
	
	// ************ result set mappings *********
	
	public void testResultSetMappings1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getResultSetMappingsSize());
	}
	
	public void testResultSetMappings2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getResultSetMappingsSize());
		
		ListIterator<String> iterator = namedQuery.getResultSetMappings().iterator();
		assertEquals("EmpRSMapping", iterator.next());
		assertEquals("AddrRSMapping", iterator.next());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"EmpRSMapping\", \"AddrRSMapping\" })", cu);
	}
	
	public void testAddResultSetMapping() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultSetMapping("ProjRSMapping");
		namedQuery.addResultSetMapping("PhRSMapping");
		
		assertEquals(2, namedQuery.getResultSetMappingsSize());

		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("PhRSMapping", namedQuery.resultSetMappingAt(1));
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"ProjRSMapping\", \"PhRSMapping\" })", cu);
	}
	
	public void testRemoveResultSetMapping1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultSetMapping("ProjRSMapping");
		
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
		
		namedQuery.removeResultSetMapping(1);
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals(2, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"EmpRSMapping\", \"ProjRSMapping\" })", cu);
		
		namedQuery.removeResultSetMapping(0);
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals(1, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = \"ProjRSMapping\")", cu);
		
		namedQuery.removeResultSetMapping(0);
		assertEquals(0, namedQuery.getResultSetMappingsSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	public void testRemoveResultSetMapping2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultSetMapping("ProjRSMapping");
		
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
		
		namedQuery.removeResultSetMapping("AddrRSMapping");
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals(2, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"EmpRSMapping\", \"ProjRSMapping\" })", cu);
		
		namedQuery.removeResultSetMapping("EmpRSMapping");
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals(1, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = \"ProjRSMapping\")", cu);
		
		namedQuery.removeResultSetMapping("ProjRSMapping");
		assertEquals(0, namedQuery.getResultSetMappingsSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	public void testMoveResultSetMapping1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addResultSetMapping("ProjRSMapping");
		
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
	
		namedQuery.moveResultSetMapping(2, 0);
		
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"AddrRSMapping\", \"ProjRSMapping\", \"EmpRSMapping\" })", cu);
	}
	
	public void testMoveResultSetMapping2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithResultSetMappings();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.addResultSetMapping("ProjRSMapping");
		
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
	
		namedQuery.moveResultSetMapping(0, 2);
		
		assertEquals("ProjRSMapping", namedQuery.resultSetMappingAt(0));
		assertEquals("EmpRSMapping", namedQuery.resultSetMappingAt(1));
		assertEquals("AddrRSMapping", namedQuery.resultSetMappingAt(2));
		assertEquals(3, namedQuery.getResultSetMappingsSize());
		assertSourceContains("@NamedStoredProcedureQuery(resultSetMappings = { \"ProjRSMapping\", \"EmpRSMapping\", \"AddrRSMapping\" })", cu);
		}

	// *********** hints ************
	
	public void testHints1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(0, namedQuery.getHintsSize());
	}
	
	public void testHints2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addHint(0);
		namedQuery.addHint(1);
		
		assertEquals(2, namedQuery.getHintsSize());
	}
	
	public void testHints3() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithHints();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		assertEquals(2, namedQuery.getHintsSize());
		
		ListIterator<QueryHintAnnotation> iterator = namedQuery.getHints().iterator();
		assertEquals("BAR", iterator.next().getName());
		assertNull(iterator.next().getName());
	}
	
	public void testAddHint() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQuery();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addHint(0).setName("FOO");
		namedQuery.addHint(1);
		namedQuery.addHint(0).setName("BAR");

		assertEquals("BAR", namedQuery.hintAt(0).getName());
		assertEquals("FOO", namedQuery.hintAt(1).getName());
		assertNull(namedQuery.hintAt(2).getName());
		assertSourceContains("@NamedStoredProcedureQuery(hints = {@QueryHint(name = \"BAR\"),@QueryHint(name = \"FOO\"), @QueryHint})", cu);
	}
	
	public void testRemoveHint() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithHints();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.addHint(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.hintAt(0).getName());
		assertEquals("BAR", namedQuery.hintAt(1).getName());
		assertNull(namedQuery.hintAt(2).getName());
		assertEquals(3, namedQuery.getHintsSize());
		
		namedQuery.removeHint(2);
		assertEquals("BAZ", namedQuery.hintAt(0).getName());
		assertEquals("BAR", namedQuery.hintAt(1).getName());
		assertEquals(2, namedQuery.getHintsSize());
		assertSourceContains("@NamedStoredProcedureQuery(hints = {@QueryHint(name = \"BAZ\"), @QueryHint(name = \"BAR\", value = \"FOO\")})", cu);
		
		namedQuery.removeHint(0);
		assertEquals("BAR", namedQuery.hintAt(0).getName());
		assertEquals(1, namedQuery.getHintsSize());
		assertSourceContains("@NamedStoredProcedureQuery(hints = @QueryHint(name = \"BAR\", value = \"FOO\"))", cu);
		
	
		namedQuery.removeHint(0);
		assertEquals(0, namedQuery.getHintsSize());
		assertSourceDoesNotContain("@NamedStoredProcedureQuery(", cu);
	}
	
	public void testMoveHint1() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithHints();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		
		namedQuery.addHint(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.hintAt(0).getName());
		assertEquals("BAR", namedQuery.hintAt(1).getName());
		assertNull(namedQuery.hintAt(2).getName());
		assertEquals(3, namedQuery.getHintsSize());
	
		namedQuery.moveHint(2, 0);
		
		assertEquals("BAR", namedQuery.hintAt(0).getName());
		assertNull(namedQuery.hintAt(1).getName());
		assertEquals("BAZ", namedQuery.hintAt(2).getName());
		assertEquals(3, namedQuery.getHintsSize());
		assertSourceContains("@NamedStoredProcedureQuery(hints = {@QueryHint(name = \"BAR\", value = \"FOO\"), @QueryHint, @QueryHint(name = \"BAZ\")})", cu);
	}
	
	public void testMoveHint2() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithHints();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		namedQuery.addHint(0).setName("BAZ");
		
		assertEquals("BAZ", namedQuery.hintAt(0).getName());
		assertEquals("BAR", namedQuery.hintAt(1).getName());
		assertNull(namedQuery.hintAt(2).getName());
		assertEquals(3, namedQuery.getHintsSize());
	
		namedQuery.moveHint(0, 2);
		
		assertNull(namedQuery.hintAt(0).getName());
		assertEquals("BAZ", namedQuery.hintAt(1).getName());
		assertEquals("BAR", namedQuery.hintAt(2).getName());
		assertEquals(3, namedQuery.getHintsSize());
		assertSourceContains("@NamedStoredProcedureQuery(hints = {@QueryHint, @QueryHint(name = \"BAZ\"), @QueryHint(name = \"BAR\", value = \"FOO\")})", cu);
	}
	
}




/*******************************************************************************
 * Copyright (c) 2013 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.tests.internal.jpa2_1.resource.java;

import java.util.Iterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.utility.internal.iterator.ArrayIterator;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annoation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

public class StoredProcedureParameter2_1AnnotationTests
	extends JavaResourceModel2_1TestCase
{

	public StoredProcedureParameter2_1AnnotationTests(String name) {
		super(name);
	}
	
	private ICompilationUnit createTestNamedStoredProcedureQueryWithParameters() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER, JPA2_1.PARAMETER_MODE);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@NamedStoredProcedureQuery(parameters = {@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = MyType.class), @StoredProcedureParameter})");
			}
		});
	}

	public void testNamedStoredProcedureQueryWithParameters() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu); 
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		assertEquals(2, namedQuery.getParametersSize());
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals("MyParameter", parameter.getName());
		parameter = namedQuery.parameterAt(1);
		assertNull(parameter.getName());
	}
	
	// ******** name *********
	
	public void testGetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu); 
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals("MyParameter", parameter.getName());
	}

	public void testSetName() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu); 
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals("MyParameter", parameter.getName());
		
		parameter.setName("foo");
		assertEquals("foo", parameter.getName());
		
		assertSourceContains("@StoredProcedureParameter(name = \"foo\", mode = ParameterMode.IN, type = MyType.class)", cu);
	}
	
	// ******* mode *********
	
	public void testGetMode() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu); 
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals(ParameterMode2_1.IN, parameter.getMode());
	}

	public void testSetMode() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu); 
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals(ParameterMode2_1.IN, parameter.getMode());
		
		parameter.setMode(ParameterMode2_1.INOUT);
		assertEquals(ParameterMode2_1.INOUT, parameter.getMode());
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = INOUT, type = MyType.class)", cu);
	
		parameter.setMode(null);
		assertNull(parameter.getMode());
		assertSourceDoesNotContain("mode", cu);
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", type = MyType.class)", cu);
	}

	// ******* type *********
	public void testGetType() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);

		assertEquals("MyType", parameter.getType());
	}

	public void testSetType() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);
		
		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);

		assertEquals("MyType", parameter.getType());
		
		parameter.setType("Foo");
		assertEquals("Foo", parameter.getType());	
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = Foo.class", cu);
		
		parameter.setType(null);
		assertNull(parameter.getType());
		assertSourceDoesNotContain("type", cu);
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN", cu);
	}

	public void testGetFullyQualifiedClass() throws Exception {
		ICompilationUnit cu = this.createTestNamedStoredProcedureQueryWithParameters();
		JavaResourceType resourceType = buildJavaResourceType(cu);

		NamedStoredProcedureQuery2_1Annoation namedQuery = (NamedStoredProcedureQuery2_1Annoation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);

		assertNotNull(parameter.getType());
		assertEquals("MyType", parameter.getFullyQualifiedTypeName());

		parameter.setType(TYPE_NAME);		
		
		assertEquals(FULLY_QUALIFIED_TYPE_NAME, parameter.getFullyQualifiedTypeName());				
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = " + TYPE_NAME + ".class)", cu);
	}
}

Return to bug 392701

Lines 24-29 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/NamedNativeQuery.java (+10 lines)
24	public interface NamedNativeQuery	24	public interface NamedNativeQuery
25	extends Query	25	extends Query
26	{	26	{
		27
		28	// ******** query ********
		29
		30	String QUERY_PROPERTY = "query"; //$NON-NLS-1$
		31
		32	String getQuery();
		33
		34	void setQuery(String query);
		35
		36
27	// ******** result class ********	37	// ******** result class ********
28		38
29	String getResultClass();	39	String getResultClass();

Lines 48-62 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/Query.java (-9 lines)
48	NamedNativeQuery.class	48	NamedNativeQuery.class
49	);	49	);
50		50
51	// ******** query ********
52
53	String QUERY_PROPERTY = "query"; //$NON-NLS-1$
54
55	String getQuery();
56
57	void setQuery(String query);
58
59
60	// ******** hints ********	51	// ******** hints ********
61		52
62	String HINTS_LIST = "hints"; //$NON-NLS-1$	53	String HINTS_LIST = "hints"; //$NON-NLS-1$

Lines 43-50 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaQuery.java (-46 lines)
43		43
44	protected String name;	44	protected String name;
45		45
46	protected String query;
47
48	protected final ContextListContainer<JavaQueryHint, QueryHintAnnotation> hintContainer;	46	protected final ContextListContainer<JavaQueryHint, QueryHintAnnotation> hintContainer;
49		47
50		48
Lines 52-58 Link Here
52	super(parent);	50	super(parent);
53	this.queryAnnotation = queryAnnotation;	51	this.queryAnnotation = queryAnnotation;
54	this.name = queryAnnotation.getName();	52	this.name = queryAnnotation.getName();
55	this.query = queryAnnotation.getQuery();
56	this.hintContainer = this.buildHintContainer();	53	this.hintContainer = this.buildHintContainer();
57	}	54	}
58		55
Lines 63-69 Link Here
63	public void synchronizeWithResourceModel() {	60	public void synchronizeWithResourceModel() {
64	super.synchronizeWithResourceModel();	61	super.synchronizeWithResourceModel();
65	this.setName_(this.queryAnnotation.getName());	62	this.setName_(this.queryAnnotation.getName());
66	this.setQuery_(this.queryAnnotation.getQuery());
67	this.syncHints();	63	this.syncHints();
68	}	64	}
69		65
Lines 89-112 Link Here
89	String old = this.name;	85	String old = this.name;
90	this.name = name;	86	this.name = name;
91	this.firePropertyChanged(NAME_PROPERTY, old, name);	87	this.firePropertyChanged(NAME_PROPERTY, old, name);
92	}
93
94
95	// ******** query ********
96
97	public String getQuery() {
98	return this.query;
99	}
100
101	public void setQuery(String query) {
102	this.queryAnnotation.setQuery(query);
103	this.setQuery_(query);
104	}
105
106	protected void setQuery_(String query) {
107	String old = this.query;
108	this.query = query;
109	this.firePropertyChanged(QUERY_PROPERTY, old, query);
110	}	88	}
111		89
112		90
Lines 198-204 Link Here
198	public void validate(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {	176	public void validate(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
199	super.validate(messages, reporter);	177	super.validate(messages, reporter);
200	this.validateName(messages);	178	this.validateName(messages);
201	this.validateQuery(queryHelper, messages, reporter);
202	}	179	}
203		180
204	protected void validateName(List<IMessage> messages) {	181	protected void validateName(List<IMessage> messages) {
Lines 215-238 Link Here
215	}	192	}
216	}	193	}
217		194
218	public void validateQuery(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter) {
219	if (StringTools.isBlank(this.query)){
220	messages.add(
221	DefaultJpaValidationMessages.buildMessage(
222	IMessage.HIGH_SEVERITY,
223	JpaValidationMessages.QUERY_STATEMENT_UNDEFINED,
224	new String[] {this.name},
225	this,
226	this.getNameTextRange()
227	)
228	);
229	} else {
230	this.validateQuery_(queryHelper, messages, reporter);
231	}
232	}
233
234	protected abstract void validateQuery_(JpaJpqlQueryHelper queryHelper, List<IMessage> messages, IReporter reporter);
235
236	public TextRange getValidationTextRange() {	195	public TextRange getValidationTextRange() {
237	TextRange textRange = this.queryAnnotation.getTextRange();	196	TextRange textRange = this.queryAnnotation.getTextRange();
238	return (textRange != null) ? textRange : this.getParent().getValidationTextRange();	197	return (textRange != null) ? textRange : this.getParent().getValidationTextRange();
Lines 240-249 Link Here
240		199
241	public TextRange getNameTextRange() {	200	public TextRange getNameTextRange() {
242	return this.getValidationTextRange(this.queryAnnotation.getNameTextRange());	201	return this.getValidationTextRange(this.queryAnnotation.getNameTextRange());
243	}
244
245	public List<TextRange> getQueryTextRanges() {
246	return this.queryAnnotation.getQueryTextRanges();
247	}	202	}
248		203
249	public boolean isEquivalentTo(JpaNamedContextNode node) {	204	public boolean isEquivalentTo(JpaNamedContextNode node) {
Lines 254-260 Link Here
254		209
255	protected boolean isEquivalentTo(Query other) {	210	protected boolean isEquivalentTo(Query other) {
256	return ObjectTools.equals(this.name, other.getName()) &&	211	return ObjectTools.equals(this.name, other.getName()) &&
257	ObjectTools.equals(this.query, other.getQuery()) &&
258	this.hintsAreEquivalentTo(other);	212	this.hintsAreEquivalentTo(other);
259	}	213	}
260		214

Added Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/NamedStoredProcedureQueries2_1AnnotationDefinition.java (+60 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 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.jpa.core.internal.jpa2_1.resource.java;
11
12	import org.eclipse.jdt.core.IAnnotation;
13	import org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryNamedAnnotation;
14	import org.eclipse.jpt.common.core.internal.resource.java.source.SourceNamedAnnotation;
15	import org.eclipse.jpt.common.core.resource.java.Annotation;
16	import org.eclipse.jpt.common.core.resource.java.AnnotationDefinition;
17	import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement;
18	import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
19	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
20
21	/**
22	* javax.persistence.NamedStoredProcedureQueries
23	*/
24	public final class NamedStoredProcedureQueries2_1AnnotationDefinition
25	implements AnnotationDefinition
26	{
27	// singleton
28	private static final AnnotationDefinition INSTANCE = new NamedStoredProcedureQueries2_1AnnotationDefinition();
29
30	/**
31	* Return the singleton.
32	*/
33	public static AnnotationDefinition instance() {
34	return INSTANCE;
35	}
36
37	/**
38	* Ensure single instance.
39	*/
40	private NamedStoredProcedureQueries2_1AnnotationDefinition() {
41	super();
42	}
43
44	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, AnnotatedElement annotatedElement) {
45	return new SourceNamedAnnotation(parent, annotatedElement, getAnnotationName());
46	}
47
48	public Annotation buildNullAnnotation(JavaResourceAnnotatedElement parent) {
49	throw new UnsupportedOperationException();
50	}
51
52	public Annotation buildAnnotation(JavaResourceAnnotatedElement parent, IAnnotation jdtAnnotation) {
53	return new BinaryNamedAnnotation(parent, jdtAnnotation, getAnnotationName());
54	}
55
56	public String getAnnotationName() {
57	return JPA2_1.NAMED_STORED_PROCEDURE_QUERIES;
58	}
59
60	}

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/JPA2_1.java (-1 / +23 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2012 Oracle. All rights reserved.	2	* Copyright (c) 2012 2013 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 36-40 Link Here
36	// JPA 2.1 annotations	36	// JPA 2.1 annotations
37	String CONVERTER = PACKAGE_ + "Converter";	37	String CONVERTER = PACKAGE_ + "Converter";
38	String CONVERTER__AUTO_APPLY = "autoApply";	38	String CONVERTER__AUTO_APPLY = "autoApply";
		39
		40	String NAMED_STORED_PROCEDURE_QUERIES = PACKAGE_ + "NamedStoredProcedureQueries";
		41	String NAMED_STORED_PROCEDURE_QUERIES__VALUE = "value";
		42	String NAMED_STORED_PROCEDURE_QUERY =PACKAGE_ + "NamedStoredProcedureQuery";
		43	String NAMED_STORED_PROCEDURE_QUERY__NAME = "name";
		44	String NAMED_STORED_PROCEDURE_QUERY__PROCEDURE_NAME= "procedureName";
		45	String NAMED_STORED_PROCEDURE_QUERY__PARAMETERS = "parameters";
		46	String NAMED_STORED_PROCEDURE_QUERY__RESULT_CLASSES = "resultClasses";
		47	String NAMED_STORED_PROCEDURE_QUERY__RESULT_SET_MAPPINGS= "resultSetMappings";
		48	String NAMED_STORED_PROCEDURE_QUERY__HINTS = "hints";
		49	String NAMED_STORED_PROCEDURE_PARAMETER = PACKAGE_ + "StoredProcedureParameter";
		50	String NAMED_STORED_PROCEDURE_PARAMETER__NAME = "name";
		51	String NAMED_STORED_PROCEDURE_PARAMETER__MODE = "mode";
		52	String NAMED_STORED_PROCEDURE_PARAMETER__TYPE = "type";
		53
		54	// JPA 2.1 enums
		55	String PARAMETER_MODE = PACKAGE_ + "ParameterMode";
		56	String PARAMETER_MODE_ = PARAMETER_MODE + '.';
		57	String PARAMETER_MODE__IN = PARAMETER_MODE_ + "IN";
		58	String PARAMETER_MODE__INOUT = PARAMETER_MODE_ + "INOUT";
		59	String PARAMETER_MODE__OUT = PARAMETER_MODE_ + "OUT";
		60	String PARAMETER_MODE__REF_CURSOR= PARAMETER_MODE_ + "REF_CURSOR";
39		61
40	}	62	}

Lines 13-20 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/details/NamedNativeQueryPropertyComposite.java (-2 / +2 lines)
13	import org.eclipse.jpt.common.ui.internal.widgets.ClassChooserPane;	13	import org.eclipse.jpt.common.ui.internal.widgets.ClassChooserPane;
14	import org.eclipse.jpt.common.ui.internal.widgets.Pane;	14	import org.eclipse.jpt.common.ui.internal.widgets.Pane;
15	import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;	15	import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;
16	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
17	import org.eclipse.jpt.common.utility.model.value.ModifiablePropertyValueModel;	16	import org.eclipse.jpt.common.utility.model.value.ModifiablePropertyValueModel;
		17	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
18	import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;	18	import org.eclipse.jpt.jpa.core.context.NamedNativeQuery;
19	import org.eclipse.jpt.jpa.core.context.Query;	19	import org.eclipse.jpt.jpa.core.context.Query;
20	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
Lines 121-127 Link Here
121	}	121	}
122		122
123	private ModifiablePropertyValueModel<String> buildQueryHolder() {	123	private ModifiablePropertyValueModel<String> buildQueryHolder() {
124	return new PropertyAspectAdapter<NamedNativeQuery, String>(getSubjectHolder(), Query.QUERY_PROPERTY) {	124	return new PropertyAspectAdapter<NamedNativeQuery, String>(getSubjectHolder(), NamedNativeQuery.QUERY_PROPERTY) {
125	@Override	125	@Override
126	protected String buildValue_() {	126	protected String buildValue_() {
127	return this.subject.getQuery();	127	return this.subject.getQuery();

Added Link Here

(-)src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/JavaResource2_1Tests.java (+33 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 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.jpa.core.tests.internal.jpa2_1.resource.java;
11
12	import junit.framework.Test;
13	import junit.framework.TestSuite;
14
15	public class JavaResource2_1Tests
16	{
17
18	public static Test suite() {
19	TestSuite suite = new TestSuite(JavaResource2_1Tests.class.getPackage().getName());
20
21	suite.addTestSuite(NamedStoredProcedureQuery2_1AnnoationTests.class);
22	suite.addTestSuite(NamedStoredProcedureQueries2_1AnnotationTests.class);
23	suite.addTestSuite(StoredProcedureParameter2_1AnnotationTests.class);
24
25	return suite;
26	}
27
28	private JavaResource2_1Tests() {
29	super();
30	throw new UnsupportedOperationException();
31	}
32
33	}