Attachment #227296 for bug #392701

Lines 65-70 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
65	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.binary;x-internal:=true,	65	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.binary;x-internal:=true,
66	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.source;x-internal:=true,	66	org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.source;x-internal:=true,
67	org.eclipse.jpt.jpa.core.internal.jpa2_1;x-internal:=true,	67	org.eclipse.jpt.jpa.core.internal.jpa2_1;x-internal:=true,
		68	org.eclipse.jpt.jpa.core.internal.jpa2_1.context,
68	org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java;x-internal:=true,	69	org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java;x-internal:=true,
69	org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm;x-internal:=true,	70	org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm;x-internal:=true,
70	org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java;x-internal:=true,	71	org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java;x-internal:=true,




package org.eclipse.jpt.jpa.core.resource.orm;

import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.ecore.impl.ENotificationImpl;

import org.eclipse.jpt.common.core.internal.utility.translators.SimpleTranslator;
import org.eclipse.jpt.common.core.resource.xml.EBaseObjectImpl;

import org.eclipse.jpt.jpa.core.resource.orm.v2_1.JPA2_1;
import org.eclipse.jpt.jpa.core.resource.orm.v2_1.OrmV2_1Package;
import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1;

	protected String description = DESCRIPTION_EDEFAULT;

	/**
	 * changed this to null and removed the generated flag so emf won't generate over it
	 * we don't want a default for enums, just null if the tag does not exist
	 * <!-- end-user-doc -->
	 * @see #getMode()
	 * @generated
	 * @ordered
	 */
	protected static final ParameterMode_2_1 MODE_EDEFAULT = null;

	/**
	 * The cached value of the '{@link #getMode() <em>Mode</em>}' attribute.




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

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;

/**
 * Container for named queries and/or named native queries and/or named stored procedure queries.
 * Used by entities and the <code>orm.xml</code>
 * </code>entity-mappings</code> element. 
 * <p>

 * 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 2.2
 */
public interface QueryContainer

	 */
	void moveNamedNativeQuery(int targetIndex, int sourceIndex);


	// ********** named stored procedure queries **********

	/**
	 * Return the container's named stored procedure queries.
	 */
	ListIterable<? extends NamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries();

	String NAMED_STORED_PROCEDURE_QUERIES_LIST = "namedStoredProcedureQueries"; //$NON-NLS-1$

	/**
	 * Return the number of named stored procedure queries.
	 */
	int getNamedStoredProcedureQueriesSize();

	/**
	 * Add a new named stored procedure query to the container and return it.
	 */
	NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery();

	/**
	 * Add a new named stored procedure query to the container at the specified index
	 * and return it.
	 */
	NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index);

	/**
	 * Remove from the container the named stored procedure query at the specified index.
	 */
	void removeNamedStoredProcedureQuery(int index);

	/**
	 * Remove the specified named stored procedure query from the container.
	 */
	void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery);

	/**
	 * Move a named stored procedure query as specified.
	 */
	void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex);

}

Lines 158-163 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/AbstractJpaNode.java (+1 lines)
158	protected JpaFactory2_0 getJpaFactory2_0() {	158	protected JpaFactory2_0 getJpaFactory2_0() {
159	return (JpaFactory2_0) this.getJpaFactory();	159	return (JpaFactory2_0) this.getJpaFactory();
160	}	160	}
		161
161	/**	162	/**
162	* Call {@link #isJpa2_1Compatible()} before calling this method.	163	* Call {@link #isJpa2_1Compatible()} before calling this method.
163	*/	164	*/

Lines 23-28 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java (-1 / +94 lines)
23	import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery;	23	import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery;
24	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;	24	import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;
25	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;	25	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
		26	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
		27	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
		28	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1;
		29	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
26	import org.eclipse.jpt.jpa.core.resource.java.NamedNativeQueryAnnotation;	30	import org.eclipse.jpt.jpa.core.resource.java.NamedNativeQueryAnnotation;
27	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;	31	import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation;
28	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	32	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
Lines 33-44 Link Here
33	*/	37	*/
34	public class GenericJavaQueryContainer	38	public class GenericJavaQueryContainer
35	extends AbstractJavaJpaContextNode	39	extends AbstractJavaJpaContextNode
36	implements JavaQueryContainer	40	implements JavaQueryContainer, JavaQueryContainer2_1
37	{	41	{
38	protected final Owner owner;	42	protected final Owner owner;
39		43
40	protected final ContextListContainer<JavaNamedQuery, NamedQueryAnnotation> namedQueryContainer;	44	protected final ContextListContainer<JavaNamedQuery, NamedQueryAnnotation> namedQueryContainer;
41	protected final ContextListContainer<JavaNamedNativeQuery, NamedNativeQueryAnnotation> namedNativeQueryContainer;	45	protected final ContextListContainer<JavaNamedNativeQuery, NamedNativeQueryAnnotation> namedNativeQueryContainer;
		46	protected final ContextListContainer<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQuery2_1Annotation> namedStoredProcedureQueryContainer;
42		47
43		48
44	public GenericJavaQueryContainer(JpaContextNode parent, Owner owner) {	49	public GenericJavaQueryContainer(JpaContextNode parent, Owner owner) {
Lines 46-51 Link Here
46	this.owner = owner;	51	this.owner = owner;
47	this.namedQueryContainer = this.buildNamedQueryContainer();	52	this.namedQueryContainer = this.buildNamedQueryContainer();
48	this.namedNativeQueryContainer = this.buildNamedNativeQueryContainer();	53	this.namedNativeQueryContainer = this.buildNamedNativeQueryContainer();
		54	this.namedStoredProcedureQueryContainer = this.buildNamedStoredProcedureQueryContainer();
49	}	55	}
50		56
51		57
Lines 56-61 Link Here
56	super.synchronizeWithResourceModel();	62	super.synchronizeWithResourceModel();
57	this.syncNamedQueries();	63	this.syncNamedQueries();
58	this.syncNamedNativeQueries();	64	this.syncNamedNativeQueries();
		65	this.syncNamedStoredProcedureQueries();
59	}	66	}
60		67
61	@Override	68	@Override
Lines 63-68 Link Here
63	super.update();	70	super.update();
64	this.updateNodes(this.getNamedQueries());	71	this.updateNodes(this.getNamedQueries());
65	this.updateNodes(this.getNamedNativeQueries());	72	this.updateNodes(this.getNamedNativeQueries());
		73	this.updateNodes(this.getNamedStoredProcedureQueries());
66	}	74	}
67		75
68		76
Lines 242-247 Link Here
242	}	250	}
243	}	251	}
244		252
		253	// ******** named stored procedure queries ********
		254
		255	public ListIterable<JavaNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries() {
		256	return this.namedStoredProcedureQueryContainer.getContextElements();
		257	}
		258
		259	public int getNamedStoredProcedureQueriesSize() {
		260	return this.namedStoredProcedureQueryContainer.getContextElementsSize();
		261	}
		262
		263	public JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() {
		264	return this.addNamedStoredProcedureQuery(this.getNamedNativeQueriesSize());
		265	}
		266
		267	public JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index) {
		268	NamedStoredProcedureQuery2_1Annotation annotation = this.addNamedStoredProcedureQueryAnnotation(index);
		269	return this.namedStoredProcedureQueryContainer.addContextElement(index, annotation);
		270	}
		271
		272	protected NamedStoredProcedureQuery2_1Annotation addNamedStoredProcedureQueryAnnotation(int index) {
		273	return (NamedStoredProcedureQuery2_1Annotation) this.owner.getResourceAnnotatedElement().addAnnotation(index, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME);
		274	}
		275
		276	public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery) {
		277	this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((JavaNamedStoredProcedureQuery2_1) namedStoredProcedureQuery));
		278	}
		279
		280	public void removeNamedStoredProcedureQuery(int index) {
		281	this.owner.getResourceAnnotatedElement().removeAnnotation(index, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME);
		282	this.namedStoredProcedureQueryContainer.removeContextElement(index);
		283	}
		284
		285	public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) {
		286	this.owner.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME);
		287	this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex);
		288	}
		289
		290	protected JavaNamedStoredProcedureQuery2_1 buildNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) {
		291	return this.isJpa2_1Compatible() ?
		292	this.getJpaFactory2_1().buildJavaNamedStoredProcedureQuery2_1(this, namedStoredProcedureQueryAnnotation) :
		293	null;
		294	}
		295
		296	protected void syncNamedStoredProcedureQueries() {
		297	this.namedStoredProcedureQueryContainer.synchronizeWithResourceModel();
		298	}
		299
		300	protected ListIterable<NamedStoredProcedureQuery2_1Annotation> getNamedStoredProcedureQueryAnnotations() {
		301	return new SubListIterableWrapper<NestableAnnotation, NamedStoredProcedureQuery2_1Annotation>(this.getNestableNamedStoredProcedureQueryAnnotations_());
		302	}
		303
		304	protected ListIterable<NestableAnnotation> getNestableNamedStoredProcedureQueryAnnotations_() {
		305	return this.owner.getResourceAnnotatedElement().getAnnotations(NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME);
		306	}
		307
		308	protected ContextListContainer<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQuery2_1Annotation> buildNamedStoredProcedureQueryContainer() {
		309	NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer();
		310	container.initialize();
		311	return container;
		312	}
		313
		314	/**
		315	* named query container
		316	*/
317	protected class NamedStoredProcedureQueryContainer
318	extends ContextListContainer<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQuery2_1Annotation>
319	{
320	@Override
321	protected String getContextElementsPropertyName() {
322	return NAMED_STORED_PROCEDURE_QUERIES_LIST;
323	}
324	@Override
325	protected JavaNamedStoredProcedureQuery2_1 buildContextElement(NamedStoredProcedureQuery2_1Annotation resourceElement) {
326	return GenericJavaQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement);
327	}
328	@Override
329	protected ListIterable<NamedStoredProcedureQuery2_1Annotation> getResourceElements() {
330	return GenericJavaQueryContainer.this.getNamedStoredProcedureQueryAnnotations();
331	}
332	@Override
333	protected NamedStoredProcedureQuery2_1Annotation getResourceElement(JavaNamedStoredProcedureQuery2_1 contextElement) {
334	return contextElement.getQueryAnnotation();
335	}
336	}
337
245		338
246	// ******** validation ********	339	// ******** validation ********
247		340




import org.eclipse.jpt.jpa.core.context.orm.OrmNamedQuery;
import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;
import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedNativeQuery;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
import org.eclipse.jpt.jpa.core.resource.orm.XmlQueryContainer;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;

 */
public class GenericOrmQueryContainer
	extends AbstractOrmXmlContextNode
	implements OrmQueryContainer, OrmQueryContainer2_1
{
	protected final XmlQueryContainer xmlQueryContainer;

	protected final ContextListContainer<OrmNamedQuery, XmlNamedQuery> namedQueryContainer;
	protected final ContextListContainer<OrmNamedNativeQuery, XmlNamedNativeQuery> namedNativeQueryContainer;
	protected final ContextListContainer<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery> namedStoredProcedureQueryContainer;


	public GenericOrmQueryContainer(JpaContextNode parent, XmlQueryContainer xmlQueryContainer) {

		this.xmlQueryContainer = xmlQueryContainer;
		this.namedQueryContainer = this.buildNamedQueryContainer();
		this.namedNativeQueryContainer = this.buildNamedNativeQueryContainer();
		this.namedStoredProcedureQueryContainer = this.buildNamedStoredProcedureQueryContainer();
	}



		super.synchronizeWithResourceModel();
		this.syncNamedQueries();
		this.syncNamedNativeQueries();
		this.syncNamedStoredProcedureQueries();
	}

	@Override

		super.update();
		this.updateNodes(this.getNamedQueries());
		this.updateNodes(this.getNamedNativeQueries());
		this.updateNodes(this.getNamedStoredProcedureQueries());
	}




	@SuppressWarnings("unchecked")
	public Iterable<Query> getQueries() {
		return IterableTools.<Query>concatenate(
				this.getNamedQueries(), 
				this.getNamedNativeQueries(),
				this.getNamedStoredProcedureQueries());
	}



	}


	// ********** named stored procedure queries **********

	public ListIterable<OrmNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries() {
		return this.namedStoredProcedureQueryContainer.getContextElements();
	}

	public int getNamedStoredProcedureQueriesSize() {
		return this.namedStoredProcedureQueryContainer.getContextElementsSize();
	}

	public OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() {
		return this.addNamedStoredProcedureQuery(this.getNamedStoredProcedureQueriesSize());
	}

	public OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index) {
		XmlNamedStoredProcedureQuery xmlQuery = this.buildXmlNamedStoredProcedureQuery();
		OrmNamedStoredProcedureQuery2_1 query = this.namedStoredProcedureQueryContainer.addContextElement(index, xmlQuery);
		this.xmlQueryContainer.getNamedStoredProcedureQueries().add(index, xmlQuery);
		return query;
	}

	protected XmlNamedStoredProcedureQuery buildXmlNamedStoredProcedureQuery() {
		return OrmFactory.eINSTANCE.createXmlNamedStoredProcedureQuery();
	}

	public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedQuery) {
		this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((OrmNamedStoredProcedureQuery2_1) namedQuery));
	}

	public void removeNamedStoredProcedureQuery(int index) {
		this.namedStoredProcedureQueryContainer.removeContextElement(index);
		this.xmlQueryContainer.getNamedStoredProcedureQueries().remove(index);
	}

	public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) {
		this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex);
		this.xmlQueryContainer.getNamedStoredProcedureQueries().move(targetIndex, sourceIndex);
	}

	protected OrmNamedStoredProcedureQuery2_1 buildNamedStoredProcedureQuery(XmlNamedStoredProcedureQuery xmlNamedQuery) {
		return this.isOrmXml2_1Compatible() ?
				this.getContextNodeFactory2_1().buildOrmNamedStoredProcedureQuery2_1(this, xmlNamedQuery) :
				null;
	}

	protected void syncNamedStoredProcedureQueries() {
		this.namedStoredProcedureQueryContainer.synchronizeWithResourceModel();
	}

	protected ListIterable<XmlNamedStoredProcedureQuery> getXmlNamedStoredProcedureQueries() {
		// clone to reduce chance of concurrency problems
		return IterableTools.cloneLive(this.xmlQueryContainer.getNamedStoredProcedureQueries());
	}

	protected ContextListContainer<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery> buildNamedStoredProcedureQueryContainer() {
		NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer();
		container.initialize();
		return container;
	}

	/**
	 * named query container
	 */
	protected class NamedStoredProcedureQueryContainer
		extends ContextListContainer<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery>
	{
		@Override
		protected String getContextElementsPropertyName() {
			return NAMED_STORED_PROCEDURE_QUERIES_LIST;
		}
		@Override
		protected OrmNamedStoredProcedureQuery2_1 buildContextElement(XmlNamedStoredProcedureQuery resourceElement) {
			return GenericOrmQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement);
		}
		@Override
		protected ListIterable<XmlNamedStoredProcedureQuery> getResourceElements() {
			return GenericOrmQueryContainer.this.getXmlNamedStoredProcedureQueries();
		}
		@Override
		protected XmlNamedStoredProcedureQuery getResourceElement(OrmNamedStoredProcedureQuery2_1 contextElement) {
			return contextElement.getXmlQuery();
		}
	}


	// ********** validation **********

	/**




 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.jpa2_1;

import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.jpa.core.context.JpaContextNode;
import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
import org.eclipse.jpt.jpa.core.internal.jpa2.GenericJpaFactory2_0;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;


/**
 * Central class that allows extenders to easily replace implementations of
 * various Dali interfaces.
 */
public class GenericJpaFactory2_1
	extends GenericJpaFactory2_0
	implements JpaFactory2_1
{

	public GenericJpaFactory2_1() {
		super();
	}
	
	public JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1(
			JavaQuery parent,
			StoredProcedureParameter2_1Annotation parameterAnnotation) {
		return new GenericJavaStoredProcedureParameter2_1(parent, parameterAnnotation);
		}

	public JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1(
			JavaQueryContainer2_1 parent, 
			NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) {
		return new GenericJavaNamedStoredProcedureQuery2_1(parent, namedStoredProcedureQueryAnnotation);
	}

	public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) {
		return new GenericJavaConverterType(parent, jrt);
	}
}




/*******************************************************************************
 * 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.context;

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.Query;

/**
 * named stored procedure query
 * <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_1
	extends Query
{

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

	String getProcedureName();
		String PROCEDURE_NAME_PROPERTY = "procedureName"; //$NON-NLS-1$

	void setProcedureName(String procedureName);


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

	/**
	 * Return the query's parameters.
	 */
	ListIterable<? extends StoredProcedureParameter2_1> getParameters();
		String PARAMETERS_LIST = "parameters"; //$NON-NLS-1$

	/**
	 * Return the number of parameters in the query.
	 */
	int getParametersSize();

	/**
	 * Add a parameter to the query and return the object representing it.
	 */
	StoredProcedureParameter2_1 addParameter();

	/**
	 * Add a parameter to the index and return the object representing it.
	 */
	StoredProcedureParameter2_1 addParameter(int index);

	/**
	 * Remove the parameter from the query.
	 */
	void removeParameter(StoredProcedureParameter2_1 parameter);

	/**
	 * Remove the parameter at the index from the query.
	 */
	void removeParameter(int index);

	/**
	 * Move the hint from the source index to the target index.
	 */
	void moveParameter(int targetIndex, int sourceIndex);

	/**
	 * Return the parameter at the index.
	 */
	StoredProcedureParameter2_1 getParameter(int index);

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

	/**
	 * Return the query's result classes.
	 */
	ListIterable<String> getResultClasses();
		String RESULT_CLASSES_LIST = "resultClasses"; //$NON-NLS-1$

	/**
	 * Return the number of result classes in the query.
	 */
	int getResultClassesSize();

	/**
	 * Return the result class at the index.
	 */
	String getResultClass(int index);

	/**
	 * Add the result class to the query.
	 */
	void addResultClass(String resultClass);

	/**
	 * Add the result class to  the index.
	 */
	void addResultClass(int index, String resultClass);

	/**
	 * Remove the result class from the query's list of result classes.
	 */
	void removeResultClass(String resultClass);

	/**
	 * Remove the result class at the index.
	 */
	void removeResultClass(int index);		
	
	/**
	 * Move the result class from the source index to the target index.
	 */
	void moveResultClass(int targetIndex, int sourceIndex);


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

	/**
	 * Return the query's result set mappings.
	 */
	ListIterable<String> getResultSetMappings();
		String RESULT_SET_MAPPINGS_LIST = "resultSetMappings"; //$NON-NLS-1$

		/**
		 * Return the number of result set mappings in the query.
		 */
		int getResultSetMappingsSize();

		/**
		 * Return the result class at the index.
		 */
		String getResultSetMapping(int index);


	/**
	 * Add the result set mapping to the query.
	 */
	void addResultSetMapping(String resultClass);

	/**
	 * Add the result set mapping to the index.
	 */
	void addResultSetMapping(int index, String resultClass);

	/**
	 * Remove the result set mapping from the query's list of result set mappings.
	 */
	void removeResultSetMapping(String resultClass);

	/**
	 * Remove the result set mapping at the index.
	 */
	void removeResultSetMapping(int index);

	/**
	 * Move the result set mapping from the source index to the target index.
	 */
	void moveResultSetMapping(int targetIndex, int sourceIndex);
}




/*******************************************************************************
 * 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.context;

import org.eclipse.jpt.jpa.core.context.JpaContextNode;
import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1;

/**
 * stored procedure parameter
 * <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_1
	extends JpaContextNode
{

	// ********* name **********
	String getName();
		String NAME_PROPERTY = "name"; //$NON-NLS-1$
	
	void setName(String name);


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

	/**
	 * Return the specified mode if present, 
	 * otherwise return the default lock mode.
	 */
	ParameterMode2_1 getMode();
	ParameterMode2_1 getSpecifiedMode();
	void setSpecifiedMode(ParameterMode2_1 mode);
		String SPECIFIED_MODE_PROPERTY = "specifiedParameterMode"; //$NON-NLS-1$
	ParameterMode2_1 getDefaultMode();
		String DEFAULT_MODE_PROPERTY = "defaultParameterMode";  //$NON-NLS-1$


	// ********** type ***********

	String getTypeName();
		String TYPE_NAME_PROPERTY = "typeName"; //$NON-NLS-1$
	
	void setTypeName(String type);

	/**
	 * If the type name is specified, this will return it fully qualified. If not
	 * specified, then it will return null
	 */
	String getFullyQualifiedTypeName();
		String FULLY_QUALIFIED_TYPE_NAME_PROPERTY = "fullyQualifiedTypeName"; //$NON-NLS-1$

	/**
	 * Return the character to be used for browsing or
	 * creating the type {@link org.eclipse.jdt.core.IType IType}.
	 * @see org.eclipse.jdt.core.IType#getFullyQualifiedName(char)
	 */
	char getTypeEnclosingTypeSeparator();


	// ********** validation ***********

	/**
	 * Return whether this stored procedure parameter is <em>equivalent</em>
	 * to the specified stored procedure parameter.
	 */
	boolean isEquivalentTo(StoredProcedureParameter2_1 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.context.java;

import java.util.ArrayList;
import java.util.Vector;
import org.eclipse.jpt.common.utility.internal.ObjectTools;
import org.eclipse.jpt.common.utility.internal.collection.ListTools;
import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.Query;
import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;
import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * <code>orm.xml</code> named stored procedure query
 */
public class GenericJavaNamedStoredProcedureQuery2_1
	extends AbstractJavaQuery<NamedStoredProcedureQuery2_1Annotation>
	implements JavaNamedStoredProcedureQuery2_1
{
		protected String procedureName;
		
		protected final ContextListContainer<JavaStoredProcedureParameter2_1, StoredProcedureParameter2_1Annotation> parameterContainer;

		protected final Vector<String> resultClasses = new Vector<String>();

		protected final Vector<String> resultSetMappings = new Vector<String>();


		public GenericJavaNamedStoredProcedureQuery2_1(JavaQueryContainer2_1 parent, NamedStoredProcedureQuery2_1Annotation queryAnnotation) {
			super(parent, queryAnnotation);
			this.procedureName = queryAnnotation.getProcedureName();
			this.parameterContainer = this.buildParameterContainer();
			this.initializeResultClasses();
			this.initializeResultSetMappings();
		}


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

		@Override
		public void synchronizeWithResourceModel() {
			super.synchronizeWithResourceModel();
			this.setProcedureName_(this.queryAnnotation.getProcedureName());
			this.syncParameters();
			this.syncResultClasses();
			this.syncResultSetMappings();
		}

		@Override
		public void update() {
			super.update();
			this.updateNodes(this.getParameters());
		}


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

	public String getProcedureName() {
		return this.procedureName;
	}

	public void setProcedureName(String procedureName) {
		this.queryAnnotation.setProcedureName(procedureName);
		this.setProcedureName_(procedureName);
	}
	
	protected void setProcedureName_(String procedureName) {
		String old = this.procedureName;
		this.procedureName = procedureName;
		this.firePropertyChanged(PROCEDURE_NAME_PROPERTY, old, procedureName);
	}

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

	public ListIterable<JavaStoredProcedureParameter2_1> getParameters() {
		return this.parameterContainer.getContextElements();
	}

	public int getParametersSize() {
		return this.parameterContainer.getContextElementsSize();
	}
	
	public JavaStoredProcedureParameter2_1 addParameter() {
		return this.addParameter(this.getParametersSize());
	}

	public JavaStoredProcedureParameter2_1 addParameter(int index) {
		StoredProcedureParameter2_1Annotation annotation = this.queryAnnotation.addParameter(index);
		return this.parameterContainer.addContextElement(index, annotation);
	}

	public void removeParameter(StoredProcedureParameter2_1 parameter) {
		this.removeParameter(this.parameterContainer.indexOfContextElement((JavaStoredProcedureParameter2_1) parameter));
	}

	public void removeParameter(int index) {
		this.queryAnnotation.removeParameter(index);
		this.parameterContainer.removeContextElement(index);
	}

	public void moveParameter(int targetIndex, int sourceIndex) {
		this.queryAnnotation.moveParameter(targetIndex, sourceIndex);
		this.parameterContainer.moveContextElement(targetIndex, sourceIndex);
	}

	public JavaStoredProcedureParameter2_1 getParameter(int index) {
		return this.parameterContainer.get(index);
	}

	protected JavaStoredProcedureParameter2_1 buildParameter(StoredProcedureParameter2_1Annotation parameterAnnotation) {
		return this.isJpa2_1Compatible() ?
				this.getJpaFactory2_1().buildJavaStoredProcedureParameter2_1(this, parameterAnnotation) :
				null;
	}

	protected void syncParameters() {
		this.parameterContainer.synchronizeWithResourceModel();
	}

	protected ListIterable<StoredProcedureParameter2_1Annotation> getParameterAnnotations() {
		return this.queryAnnotation.getParameters();
	}

	protected ContextListContainer<JavaStoredProcedureParameter2_1, StoredProcedureParameter2_1Annotation> buildParameterContainer() {
		ParameterContainer container = new ParameterContainer();
		container.initialize();
		return container;
	}

	/**
	 * stored procedure parameter container
	 */
	protected class ParameterContainer
		extends ContextListContainer<JavaStoredProcedureParameter2_1, StoredProcedureParameter2_1Annotation>
	{
		@Override
		protected String getContextElementsPropertyName() {
			return PARAMETERS_LIST;
		}
		@Override
		protected JavaStoredProcedureParameter2_1 buildContextElement(StoredProcedureParameter2_1Annotation resourceElement) {
			return GenericJavaNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement);
		}
		@Override
		protected ListIterable<StoredProcedureParameter2_1Annotation> getResourceElements() {
			return GenericJavaNamedStoredProcedureQuery2_1.this.getParameterAnnotations();
		}
		@Override
		protected StoredProcedureParameter2_1Annotation getResourceElement(JavaStoredProcedureParameter2_1 contextElement) {
			return contextElement.getStoredProcedureParameter2_1Annotation();
		}
	}


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

	public ListIterable<String> getResultClasses() {
		return IterableTools.cloneLive(this.resultClasses);
	}

	public int getResultClassesSize() {
		return this.resultClasses.size();
	}
	
	public String getResultClass(int index) {
		return this.resultClasses.get(index);
	}
	
	public void addResultClass(String resultClass) {
		this.addResultClass(this.resultClasses.size(), resultClass);
	}
	
	public void addResultClass(int index, String resultClass) {
		this.queryAnnotation.addResultClass(index, resultClass);
		this.addItemToList(index, resultClass, this.resultClasses, RESULT_CLASSES_LIST);
	}

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

	public void removeResultClass(int index) {
		this.queryAnnotation.removeResultClass(index);
		this.removeItemFromList(index, this.resultClasses, RESULT_CLASSES_LIST);
	}

	public void moveResultClass(int targetIndex, int sourceIndex) {
		this.queryAnnotation.moveResultClass(targetIndex, sourceIndex);
		this.moveItemInList(targetIndex, sourceIndex, this.resultClasses, RESULT_CLASSES_LIST);
	}
	
	protected void initializeResultClasses() {
		for (String resultClass : this.getResourceResultClasses()) {
			this.resultClasses.add(resultClass);
		}
	}

	protected void syncResultClasses() {
		this.synchronizeList(this.getResourceResultClasses(), this.resultClasses, RESULT_CLASSES_LIST);
	}

	protected Iterable<String> getResourceResultClasses() {
		return this.queryAnnotation.getResultClasses();
	}


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

	public ListIterable<String> getResultSetMappings() {
		return IterableTools.cloneLive(this.resultSetMappings);
	}

	public int getResultSetMappingsSize() {
		return this.resultSetMappings.size();
	}
	
	public String getResultSetMapping(int index) {
		return this.resultSetMappings.get(index);
	}
	
	public void addResultSetMapping(String resultSetMapping) {
		this.addResultSetMapping(this.resultSetMappings.size(), resultSetMapping);
	}
	
	public void addResultSetMapping(int index, String resultSetMapping) {
		this.queryAnnotation.addResultSetMapping(index, resultSetMapping);
		this.addItemToList(index, resultSetMapping, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	}

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

	public void removeResultSetMapping(int index) {
		this.queryAnnotation.removeResultSetMapping(index);
		this.removeItemFromList(index, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	}

	public void moveResultSetMapping(int targetIndex, int sourceIndex) {
		this.queryAnnotation.moveResultSetMapping(targetIndex, sourceIndex);
		this.moveItemInList(targetIndex, sourceIndex, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	}
	
	protected void initializeResultSetMappings() {
		for (String resultSetMapping : this.getResourceResultSetMappings()) {
			this.resultSetMappings.add(resultSetMapping);
		}
	}

	protected void syncResultSetMappings() {
		this.synchronizeList(this.getResourceResultSetMappings(), this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	}

	protected Iterable<String> getResourceResultSetMappings() {
		return this.queryAnnotation.getResultSetMappings();
	}

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


	// ********** metadata conversion *********
	
	public void convertTo(OrmQueryContainer queryContainer) {
		((OrmQueryContainer2_1) queryContainer).addNamedStoredProcedureQuery().convertFrom(this);
	}

	public void delete() {
		this.getParent().removeNamedStoredProcedureQuery(this);
	}


	// ********** validation **********

	@Override
	protected boolean isEquivalentTo(Query other) {
		return super.isEquivalentTo(other)
				&& this.isEquivalentTo((NamedStoredProcedureQuery2_1) other);
	}

	protected boolean isEquivalentTo(NamedStoredProcedureQuery2_1 other) {
		return ObjectTools.equals(this.procedureName, other.getProcedureName()) &&
				this.parametersAreEquivalentTo(other) &&
				this.valuesAreEquivalent(other, this.getResultClasses(), other.getResultClasses()) &&
				this.valuesAreEquivalent(other, this.getResultSetMappings(), other.getResultSetMappings());
	}

	protected boolean valuesAreEquivalent(NamedStoredProcedureQuery2_1 other, ListIterable<String> list1, ListIterable<String> list2) {
		ArrayList<String> stringList1 = ListTools.list(list1);
		ArrayList<String> stringList2 = ListTools.list(list2);
		if (stringList1.size() != stringList2.size()) {
			return false;
		}
		for (int i = 0; i < stringList1.size(); i++) {
			if ( !ObjectTools.equals(stringList1.get(i), stringList2.get(i))) {
				return false;
			}
		}
		return true;
	}

	protected boolean parametersAreEquivalentTo(NamedStoredProcedureQuery2_1 other) {
		// get fixed lists of the stored procedure parameters
		ArrayList<JavaStoredProcedureParameter2_1> parameter1 = ListTools.list(this.getParameters());
		ArrayList<? extends StoredProcedureParameter2_1> parameter2 = ListTools.list(other.getParameters());
		if (parameter1.size() != parameter2.size()) {
			return false;
		}
		for (int i = 0; i < parameter1.size(); i++) {
			if ( ! parameter1.get(i).isEquivalentTo(parameter2.get(i))) {
				return false;
			}
		}
		return true;
	}

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

	public Class<NamedStoredProcedureQuery2_1> getType() {
		return NamedStoredProcedureQuery2_1.class;
	}

}




/*******************************************************************************
 * 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.context.java;

import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.ObjectTools;
import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * Java stored procedure parameter
 */
public class GenericJavaStoredProcedureParameter2_1
	extends AbstractJavaJpaContextNode
	implements JavaStoredProcedureParameter2_1
{
	protected final StoredProcedureParameter2_1Annotation parameterAnnotation;

	protected String name;
	
	protected ParameterMode2_1 specifiedMode;
	protected ParameterMode2_1 defaultMode;
	
	protected String typeName;
	protected String fullyQualifiedTypeName;


	public GenericJavaStoredProcedureParameter2_1(JavaQuery parent, StoredProcedureParameter2_1Annotation parameterAnnotation) {
		super(parent);
		this.parameterAnnotation = parameterAnnotation;
		this.name = parameterAnnotation.getName();
		this.specifiedMode = this.buildSpecifiedMode();
		this.typeName = parameterAnnotation.getTypeName();
	}


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

	@Override
	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.setName_(this.parameterAnnotation.getName());
		this.setSpecifiedMode_(this.buildSpecifiedMode());
		this.setTypeName_(this.parameterAnnotation.getTypeName());
	}

	@Override
	public void update() {
		super.update();
		this.setDefaultMode(this.buildDefaultMode());
		this.setFullyQualifiedTypeName(this.buildFullyQualifiedTypeName());
	}

	// ********* name **************

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

	public void setName(String name) {
		this.parameterAnnotation.setName(name);
		this.setName_(name);
	}

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


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

	public ParameterMode2_1 getMode() {
		return (this.specifiedMode != null) ? this.specifiedMode : this.defaultMode;
	}

	public ParameterMode2_1 getSpecifiedMode() {
		return this.specifiedMode;
	}

	public void setSpecifiedMode(ParameterMode2_1 mode) {
		((StoredProcedureParameter2_1Annotation) this.parameterAnnotation).setMode(ParameterMode2_1.toJavaResourceModel(mode));
		this.setSpecifiedMode_(mode);
	}

	protected void setSpecifiedMode_(ParameterMode2_1 mode) {
		ParameterMode2_1 old = this.specifiedMode;
		this.specifiedMode = mode;
		this.firePropertyChanged(SPECIFIED_MODE_PROPERTY, old, mode);
	}

	protected ParameterMode2_1 buildSpecifiedMode() {
		return this.isJpa2_1Compatible() ?
			ParameterMode2_1.fromJavaResourceModel(((StoredProcedureParameter2_1Annotation) this.parameterAnnotation).getMode()) :
			null;
	}

	public ParameterMode2_1 getDefaultMode() {
		return this.defaultMode;
	}

	protected void setDefaultMode(ParameterMode2_1 mode) {
		ParameterMode2_1 old = this.defaultMode;
		this.defaultMode = mode;
		this.firePropertyChanged(DEFAULT_MODE_PROPERTY, old, mode);
	}

	protected ParameterMode2_1 buildDefaultMode() {
		return this.isJpa2_1Compatible() ?  ParameterMode2_1.IN : null;
	}


	// ********** type **********

	public String getTypeName() {
		return this.typeName;
	}

	public void setTypeName(String typeName) {
		this.parameterAnnotation.setTypeName(typeName);
		this.setTypeName_(typeName);
	}

	protected void setTypeName_(String typeName) {
		String old = this.typeName;
		this.typeName = typeName;
		this.firePropertyChanged(TYPE_NAME_PROPERTY, old, typeName);
	}

	public String getFullyQualifiedTypeName() {
		return this.fullyQualifiedTypeName;
	}

	protected void setFullyQualifiedTypeName(String typeName) {
		String old = this.fullyQualifiedTypeName;
		this.fullyQualifiedTypeName = typeName;
		this.firePropertyChanged(FULLY_QUALIFIED_TYPE_NAME_PROPERTY, old, typeName);
	}

	protected String buildFullyQualifiedTypeName() {
		return this.parameterAnnotation.getFullyQualifiedTypeName();
	}

	public char getTypeEnclosingTypeSeparator() {
		return '.';
	}


	// ********** validation **********

	public TextRange getValidationTextRange() {
		TextRange textRange = this.parameterAnnotation.getTextRange();
		return (textRange != null) ? textRange : this.getQuery().getValidationTextRange();
	}

	public boolean isEquivalentTo(StoredProcedureParameter2_1 parameter) {
		return ObjectTools.equals(this.name, parameter.getName()) &&
				ObjectTools.equals(this.specifiedMode, parameter.getMode()) &&
				ObjectTools.equals(this.typeName, parameter.getTypeName()) ;
	}


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

	@Override
	public JavaQuery getParent() {
		return (JavaQuery) super.getParent();
	}

	protected JavaQuery getQuery() {
		return this.getParent();
	}

	public StoredProcedureParameter2_1Annotation getStoredProcedureParameter2_1Annotation() {
		return this.parameterAnnotation;
	}

}




/*******************************************************************************
 * 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.context.java;

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;

/**
 * Java named stored procedure query
 * <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 JavaNamedStoredProcedureQuery2_1
	extends NamedStoredProcedureQuery2_1, JavaQuery
{
	NamedStoredProcedureQuery2_1Annotation getQueryAnnotation();

	// *********** parameters ************
	
	ListIterable<JavaStoredProcedureParameter2_1> getParameters();

	JavaStoredProcedureParameter2_1 addParameter();

	JavaStoredProcedureParameter2_1 addParameter(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.internal.jpa2_1.context.java;

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer;

/**
 * Java query container for JPA 2.1
 * <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 JavaQueryContainer2_1
	extends JavaQueryContainer
{
	// ********** named stored procedure queries **********

	ListIterable<JavaNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries();

	JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery();

	JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(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.internal.jpa2_1.context.java;

import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**
 * Java stored procedure parameter
 * <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 JavaStoredProcedureParameter2_1
	extends StoredProcedureParameter2_1
{
	StoredProcedureParameter2_1Annotation getStoredProcedureParameter2_1Annotation();
}




/*******************************************************************************
 * 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.context.orm;

import java.util.ArrayList;
import java.util.Vector;
import org.eclipse.jpt.common.utility.internal.ObjectTools;
import org.eclipse.jpt.common.utility.internal.collection.ListTools;
import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.JpaContextNode;
import org.eclipse.jpt.jpa.core.context.Query;
import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;

public class GenericOrmNamedStoredProcedureQuery2_1
	extends AbstractOrmQuery<XmlNamedStoredProcedureQuery>
	implements OrmNamedStoredProcedureQuery2_1
{
	protected String procedureName;
	
	protected final ContextListContainer<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter> parameterContainer;

	protected final Vector<String> resultClasses = new Vector<String>();

	protected final Vector<String> resultSetMappings = new Vector<String>();


	public GenericOrmNamedStoredProcedureQuery2_1(JpaContextNode parent, XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) {
		super(parent, xmlNamedStoredProcedureQuery);
		this.procedureName = this.xmlQuery.getProcedureName();
		this.parameterContainer = this.buildParameterContainer();
		this.initializeResultClasses();
		this.initializeResultSetMappings();
	}


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

	@Override
	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.setProcedureName_(this.xmlQuery.getProcedureName());
		this.syncParameters();
		this.syncResultClasses();
		this.syncResultSetMappings();
	}

	@Override
	public void update() {
		super.update();
		this.updateNodes(this.getParameters());
	}


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

public String getProcedureName() {
	return this.procedureName;
}

public void setProcedureName(String procedureName) {
	this.xmlQuery.setProcedureName(procedureName);
	this.setProcedureName_(procedureName);
}

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

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

public ListIterable<OrmStoredProcedureParameter2_1> getParameters() {
	return this.parameterContainer.getContextElements();
}

public int getParametersSize() {
	return this.parameterContainer.getContextElementsSize();
}

public OrmStoredProcedureParameter2_1 addParameter() {
	return this.addParameter(this.getParametersSize());
}

public OrmStoredProcedureParameter2_1 addParameter(int index) {
	XmlStoredProcedureParameter xmlParameter = this.buildXmlStoredProcedureParameter();
	OrmStoredProcedureParameter2_1 parameter = this.parameterContainer.addContextElement(index, xmlParameter);
	this.xmlQuery.getParameters().add(index, xmlParameter);
	return parameter;
}

protected XmlStoredProcedureParameter buildXmlStoredProcedureParameter() {
	return OrmFactory.eINSTANCE.createXmlStoredProcedureParameter();
}

public void removeParameter(StoredProcedureParameter2_1 parameter) {
	this.removeParameter(this.parameterContainer.indexOfContextElement((OrmStoredProcedureParameter2_1) parameter));
}

public void removeParameter(int index) {
	this.parameterContainer.removeContextElement(index);
	this.xmlQuery.getParameters().remove(index);
}

public void moveParameter(int targetIndex, int sourceIndex) {
	this.parameterContainer.moveContextElement(targetIndex, sourceIndex);
	this.xmlQuery.getParameters().move(targetIndex, sourceIndex);
}

public OrmStoredProcedureParameter2_1 getParameter(int index) {
	return this.parameterContainer.get(index);
}

protected OrmStoredProcedureParameter2_1 buildParameter(XmlStoredProcedureParameter xmlParameter) {
	return this.isOrmXml2_1Compatible() ?
			this.getContextNodeFactory2_1().buildOrmStoredProcedureParameter(this, xmlParameter) : 
			null;
}

protected void syncParameters() {
	this.parameterContainer.synchronizeWithResourceModel();
}

protected ListIterable<XmlStoredProcedureParameter> getXmlParameters() {
	// clone to reduce chance of concurrency problems
	return IterableTools.cloneLive(this.xmlQuery.getParameters());
}

protected ContextListContainer<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter> buildParameterContainer() {
	ParameterContainer container = new ParameterContainer();
	container.initialize();
	return container;
}

/**
 * query hint container
 */
protected class ParameterContainer
	extends ContextListContainer<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter>
{
	@Override
	protected String getContextElementsPropertyName() {
		return PARAMETERS_LIST;
	}
	@Override
	protected OrmStoredProcedureParameter2_1 buildContextElement(XmlStoredProcedureParameter resourceElement) {
		return GenericOrmNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement);
	}
	@Override
	protected ListIterable<XmlStoredProcedureParameter> getResourceElements() {
		return GenericOrmNamedStoredProcedureQuery2_1.this.getXmlParameters();
	}
	@Override
	protected XmlStoredProcedureParameter getResourceElement(OrmStoredProcedureParameter2_1 contextElement) {
		return contextElement.getXmlStoredProcedureParameter();
	}
}


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

public ListIterable<String> getResultClasses() {
	return IterableTools.cloneLive(this.resultClasses);
}

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

public String getResultClass(int index) {
	return this.resultClasses.get(index);
}

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

public void addResultClass(int index, String resultClass) {
	this.addItemToList(index, resultClass, this.resultClasses, RESULT_CLASSES_LIST);
	this.xmlQuery.getResultClasses().add(index, resultClass);
}

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

public void removeResultClass(int index) {
	this.removeItemFromList(index, this.resultClasses, RESULT_CLASSES_LIST);
	this.xmlQuery.getResultClasses().remove(index);
}

public void moveResultClass(int targetIndex, int sourceIndex) {
	this.moveItemInList(targetIndex, sourceIndex, this.resultClasses, RESULT_CLASSES_LIST);
	this.xmlQuery.getResultClasses().move(targetIndex, sourceIndex);
}

protected void initializeResultClasses() {
	for (String resultClass : this.getResourceResultClasses()) {
		this.resultClasses.add(resultClass);
	}
}

protected void syncResultClasses() {
	this.synchronizeList(this.getResourceResultClasses(), this.resultClasses, RESULT_CLASSES_LIST);
}

protected Iterable<String> getResourceResultClasses() {
	return this.xmlQuery.getResultClasses();
}


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

public ListIterable<String> getResultSetMappings() {
	return IterableTools.cloneLive(this.resultSetMappings);
}

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

public String getResultSetMapping(int index) {
	return this.resultSetMappings.get(index);
}

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

public void addResultSetMapping(int index, String resultSetMapping) {
	this.addItemToList(index, resultSetMapping, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	this.xmlQuery.getResultSetMappings().add(index, resultSetMapping);
}

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

public void removeResultSetMapping(int index) {
	this.removeItemFromList(index, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	this.xmlQuery.getResultSetMappings().remove(index);
}

public void moveResultSetMapping(int targetIndex, int sourceIndex) {
	this.moveItemInList(targetIndex, sourceIndex, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
	this.xmlQuery.getResultSetMappings().move(targetIndex, sourceIndex);
}

protected void initializeResultSetMappings() {
	for (String resultSetMapping : this.getResourceResultSetMappings()) {
		this.resultSetMappings.add(resultSetMapping);
	}
}

protected void syncResultSetMappings() {
	this.synchronizeList(this.getResourceResultSetMappings(), this.resultSetMappings, RESULT_SET_MAPPINGS_LIST);
}

protected Iterable<String> getResourceResultSetMappings() {
	return this.xmlQuery.getResultSetMappings();
}

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


// ********** metadata conversion *********

public void convertFrom(JavaNamedStoredProcedureQuery2_1 javaQuery) {
	super.convertFrom(javaQuery);
	this.setName(javaQuery.getName());
	this.setProcedureName(javaQuery.getProcedureName());
	for (JavaStoredProcedureParameter2_1 javaParameter : javaQuery.getParameters()) {
		this.addParameter().convertFrom(javaParameter);
	}
	for (String resultClass : javaQuery.getResultClasses()) {
		this.addResultClass(resultClass);
	}
	for (String resultSetMapping : javaQuery.getResultSetMappings()) {
		this.addResultSetMapping(resultSetMapping);
	}
}


// ********** validation **********

@Override
protected boolean isEquivalentTo(Query other) {
	return super.isEquivalentTo(other)
			&& this.isEquivalentTo((NamedStoredProcedureQuery2_1) other);
}

protected boolean isEquivalentTo(NamedStoredProcedureQuery2_1 other) {
	return ObjectTools.equals(this.procedureName, other.getProcedureName()) &&
			this.parametersAreEquivalentTo(other) &&
			this.valuesAreEquivalent(other, this.getResultClasses(), other.getResultClasses()) &&
			this.valuesAreEquivalent(other, this.getResultSetMappings(), other.getResultSetMappings());
}

protected boolean valuesAreEquivalent(NamedStoredProcedureQuery2_1 other, ListIterable<String> list1, ListIterable<String> list2) {
	ArrayList<String> stringList1 = ListTools.list(list1);
	ArrayList<String> stringList2 = ListTools.list(list2);
	if (stringList1.size() != stringList2.size()) {
		return false;
	}
	for (int i = 0; i < stringList1.size(); i++) {
		if ( !ObjectTools.equals(stringList1.get(i), stringList2.get(i))) {
			return false;
		}
	}
	return true;
}

protected boolean parametersAreEquivalentTo(NamedStoredProcedureQuery2_1 other) {
	// get fixed lists of the stored procedure parameters
	ArrayList<OrmStoredProcedureParameter2_1> parameter1 = ListTools.list(this.getParameters());
	ArrayList<? extends StoredProcedureParameter2_1> parameter2 = ListTools.list(other.getParameters());
	if (parameter1.size() != parameter2.size()) {
		return false;
	}
	for (int i = 0; i < parameter1.size(); i++) {
		if ( ! parameter1.get(i).isEquivalentTo(parameter2.get(i))) {
			return false;
		}
	}
	return true;
}

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

public Class<NamedStoredProcedureQuery2_1> getType() {
	return NamedStoredProcedureQuery2_1.class;
}

}




/*******************************************************************************
 * 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.context.orm;

import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.ObjectTools;
import org.eclipse.jpt.jpa.core.context.orm.OrmQuery;
import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;

public class GenericOrmStoredProcedureParameter2_1
	extends AbstractOrmXmlContextNode
	implements OrmStoredProcedureParameter2_1
{

	protected final XmlStoredProcedureParameter xmlStoredProcedureParameter;

	protected String name;
	
	protected ParameterMode2_1 specifiedMode;
	protected ParameterMode2_1 defaultMode;

	protected String typeName;
	protected String fullyQualifiedTypeName;


	public GenericOrmStoredProcedureParameter2_1(
			OrmQuery parent,
			XmlStoredProcedureParameter xmlStoredProcedureParameter) {
		super(parent);
		this.xmlStoredProcedureParameter = xmlStoredProcedureParameter;
		this.name = xmlStoredProcedureParameter.getName();
		this.specifiedMode = this.buildSpecifiedMode();
		this.typeName = xmlStoredProcedureParameter.getClassName();
	}


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

	@Override
	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.setName_(this.xmlStoredProcedureParameter.getName());
		this.setSpecifiedMode_(this.buildSpecifiedMode());
		this.setTypeName_(this.xmlStoredProcedureParameter.getClassName());
	}

	@Override
	public void update() {
		super.update();
		this.setDefaultMode(this.buildDefaultMode());
		this.setFullyQualifiedTypeName(this.buildFullyQualifiedTypeName());
	}

	// ********** name **********

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

	public void setName(String name) {
		this.setName_(name);
		this.xmlStoredProcedureParameter.setName(name);
	}

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


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

	public ParameterMode2_1 getMode() {
		return (this.specifiedMode != null) ? this.specifiedMode : this.defaultMode;
	}

	public ParameterMode2_1 getSpecifiedMode() {
		return this.specifiedMode;
	}

	public void setSpecifiedMode(ParameterMode2_1 mode) {
		this.xmlStoredProcedureParameter.setMode(ParameterMode2_1.toOrmResourceModel(mode));
		this.setSpecifiedMode_(mode);
	}

	public void setSpecifiedMode_(ParameterMode2_1 mode) {
		ParameterMode2_1 old = this.specifiedMode;
		this.specifiedMode = mode;
		this.firePropertyChanged(SPECIFIED_MODE_PROPERTY, old, mode);
	}

	protected ParameterMode2_1 buildSpecifiedMode() {
		return this.isJpa2_1Compatible() ? 
				ParameterMode2_1.fromOrmResourceModel(this.xmlStoredProcedureParameter.getMode()) :
				null;
	}

	public ParameterMode2_1 getDefaultMode() {
		return this.defaultMode;
	}

	protected void setDefaultMode(ParameterMode2_1 mode) {
		ParameterMode2_1 old = this.defaultMode;
		this.defaultMode = mode;
		this.firePropertyChanged(DEFAULT_MODE_PROPERTY, old, mode);
	}

	protected ParameterMode2_1 buildDefaultMode() {
		return this.isJpa2_1Compatible() ? ParameterMode2_1.IN : null;
	}


	// ********** type **********

	public String getTypeName() {
		return this.typeName;
	}

	public void setTypeName(String typeName) {
		this.xmlStoredProcedureParameter.setClassName(typeName);
		this.setTypeName_(typeName);
	}

	protected void setTypeName_(String typeName) {
		String old = this.typeName;
		this.typeName = typeName;
		this.firePropertyChanged(TYPE_NAME_PROPERTY, old, typeName);
	}

	public String getFullyQualifiedTypeName() {
		return this.fullyQualifiedTypeName;
	}

	protected void setFullyQualifiedTypeName(String typeName) {
		String old = this.fullyQualifiedTypeName;
		this.fullyQualifiedTypeName = typeName;
		this.firePropertyChanged(FULLY_QUALIFIED_TYPE_NAME_PROPERTY, old, typeName);
	}

	protected String buildFullyQualifiedTypeName() {
		return this.getMappingFileRoot().qualify(this.typeName);
	}

	public char getTypeEnclosingTypeSeparator() {
		return '$';
	}

	// ********** metadata conversion **********
 
	public void convertFrom(JavaStoredProcedureParameter2_1 javaParameter) {
		this.setName(javaParameter.getName());
		this.setSpecifiedMode(javaParameter.getMode());
		this.setTypeName(javaParameter.getTypeName());
	}

	// ********** validation **********

	public TextRange getValidationTextRange() {
		TextRange textRange = this.xmlStoredProcedureParameter.getValidationTextRange();
		return (textRange != null) ? textRange : this.getQuery().getValidationTextRange();
	}

	public boolean isEquivalentTo(StoredProcedureParameter2_1 parameter) {
		return ObjectTools.equals(this.name, parameter.getName()) &&
				ObjectTools.equals(this.specifiedMode, parameter.getSpecifiedMode()) &&
				ObjectTools.equals(this.typeName, parameter.getTypeName());
	}

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

	@Override
	public OrmQuery getParent() {
		return (OrmQuery) super.getParent();
	}

	protected OrmQuery getQuery() {
		return this.getParent();
	}

	public XmlStoredProcedureParameter getXmlStoredProcedureParameter() {
		return this.xmlStoredProcedureParameter;
	}

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

Lines 14-19 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmXml2_1ContextNodeFactory.java (+14 lines)
14	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1;	14	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1;
15	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory;	15	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory;
16	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;	16	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;
		17	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
		18	import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;
17		19
18	public class GenericOrmXml2_1ContextNodeFactory	20	public class GenericOrmXml2_1ContextNodeFactory
19	extends GenericOrmXml2_0ContextNodeFactory	21	extends GenericOrmXml2_0ContextNodeFactory
Lines 23-26 Link Here
23	public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) {	25	public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) {
24	return new GenericOrmConverterType(parent, xmlConverter);	26	return new GenericOrmConverterType(parent, xmlConverter);
25	}	27	}
		28
		29	public OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1(
		30	OrmQueryContainer2_1 parent,
		31	XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) {
		32	return new GenericOrmNamedStoredProcedureQuery2_1(parent, xmlNamedStoredProcedureQuery);
		33	}
		34
		35	public OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter(
		36	OrmNamedStoredProcedureQuery2_1 parent,
		37	XmlStoredProcedureParameter xmlParameter) {
		38	return new GenericOrmStoredProcedureParameter2_1(parent, xmlParameter);
		39	}
26	}	40	}




/*******************************************************************************
 * 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.context.orm;

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.orm.OrmQuery;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;

public interface OrmNamedStoredProcedureQuery2_1
	extends OrmQuery, NamedStoredProcedureQuery2_1
{
	XmlNamedStoredProcedureQuery getXmlQuery();
	
	// *********** parameters ************
	
	ListIterable<OrmStoredProcedureParameter2_1> getParameters();

	OrmStoredProcedureParameter2_1 addParameter();

	OrmStoredProcedureParameter2_1 addParameter(int index);

	// ********** metadata conversion *********
	
	/**
	 * Build up a mapping file query from
	 * the given Java query
	 */
	void convertFrom(JavaNamedStoredProcedureQuery2_1 javaQuery);

}




/*******************************************************************************
 * 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.context.orm;

import org.eclipse.jpt.common.utility.iterable.ListIterable;
import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer;

public interface OrmQueryContainer2_1
	extends OrmQueryContainer
{
	// ********** named stored procedure queries **********

	ListIterable<OrmNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries();

	OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery();

	OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(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.internal.jpa2_1.context.orm;

import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;

public interface OrmStoredProcedureParameter2_1
	extends StoredProcedureParameter2_1
{
	XmlStoredProcedureParameter getXmlStoredProcedureParameter();

	// ****** metadata conversion ****
	/**
	 * Build up a mapping file stored procedure parameter
	 * from the given Java stored procedure parameter
	 */
	void convertFrom(JavaStoredProcedureParameter2_1 javaStoredProcedureParameter);

}




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.ParameterMode_2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**

	implements StoredProcedureParameter2_1Annotation
{
	private String name;
	private ParameterMode_2_1 mode;
	private String type;



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

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

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

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

	public TextRange getModeTextRange() {

	}

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

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





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.ParameterMode_2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

/**


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

	private DeclarationAnnotationElementAdapter<String> typeDeclarationAdapter;

	}

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

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

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

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

	public TextRange getModeTextRange() {

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

	public void setTypeName(String type) {
		if (this.attributeValueHasChanged(this.type, type)) {
			this.type = type;
			this.fqTypeNameStale = true;

Lines 11-18 Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/JpaFactory2_1.java (-5 / +20 lines)
11		11
12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;	12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;	13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;
		14	import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
		15	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
		16	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1;
		17	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
14	import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;	18	import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;
15	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;	19	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;
		20	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
		21	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
16		22
17	/**	23	/**
18	* JPA 2.1 factory	24	* JPA 2.1 factory
Lines 25-34 Link Here
25	*	31	*
26	* @version 3.3	32	* @version 3.3
27	* @since 3.3	33	* @since 3.3
28	*/	34	*/
29	public interface JpaFactory2_1	35	public interface JpaFactory2_1
30	extends JpaFactory2_0	36	extends JpaFactory2_0
31	{	37	{
32		38	// ******** Java Context Model ********
		39
33	JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt);	40	JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt);
34	}	41
		42	JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1(
		43	JavaQuery parent,
		44	StoredProcedureParameter2_1Annotation parameterAnnotation);
		45
		46	JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1(
		47	JavaQueryContainer2_1 parent,
		48	NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation);
		49	}




/*******************************************************************************
* 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;


/**
 * parameter mode
 * 
 * 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(
		org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.IN,
		org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.IN
		),
	INOUT(
			org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.INOUT,
			org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.INOUT
		),
	OUT(
			org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.OUT,
			org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.OUT
		),
	REF_CURSOR(
			org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.REF_CURSOR,
			org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.REF_CURSOR
		);


	private org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode;
	private org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode;

	ParameterMode2_1(
			org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode,
			org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
		if (javaParameterMode == null) {
			throw new NullPointerException();
		}
		if (ormParameterMode == null) {
			throw new NullPointerException();
		}
		this.javaParameterMode = javaParameterMode;
		this.ormParameterMode = ormParameterMode;
	}

	public org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 getJavaParameterMode() {
		return this.javaParameterMode;
	}

	public org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 getOrmParameterMode() {
		return this.ormParameterMode;
	}


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

	public static ParameterMode2_1 fromJavaResourceModel(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) {
		return (javaParameterMode == null) ? null : fromJavaResourceModel_(javaParameterMode);
	}

	private static ParameterMode2_1 fromJavaResourceModel_(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) {
		for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) {
			if (parameterMode.getJavaParameterMode() == javaParameterMode) {
				return parameterMode;
			}
		}
		return null;
	}

	public static org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 toJavaResourceModel(ParameterMode2_1 parameterMode) {
		return (parameterMode == null) ? null : parameterMode.getJavaParameterMode();
	}


	public static ParameterMode2_1 fromOrmResourceModel(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
		return (ormParameterMode == null) ? null : fromOrmResourceModel_(ormParameterMode);
	}

	private static ParameterMode2_1 fromOrmResourceModel_(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
		for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) {
			if (parameterMode.getOrmParameterMode() == ormParameterMode) {
				return parameterMode;
			}
		}
		return null;
	}

	public static org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 toOrmResourceModel(ParameterMode2_1 parameterMode) {
		return (parameterMode == null) ? null : parameterMode.getOrmParameterMode();
	}
}

Lines 11-16 Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/context/orm/OrmXml2_1ContextNodeFactory.java (+13 lines)
11		11
12	import org.eclipse.jpt.jpa.core.context.orm.OrmXmlContextNodeFactory;	12	import org.eclipse.jpt.jpa.core.context.orm.OrmXmlContextNodeFactory;
13	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;	13	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;
		14	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1;
		15	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
		16	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1;
		17	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
		18	import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;
14		19
15	/**	20	/**
16	* JPA 2.1 <code>orm.xml</code> context node factory	21	* JPA 2.1 <code>orm.xml</code> context node factory
Lines 28-31 Link Here
28	extends OrmXmlContextNodeFactory	33	extends OrmXmlContextNodeFactory
29	{	34	{
30	OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter);	35	OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter);
		36
		37	OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1(
		38	OrmQueryContainer2_1 parent,
		39	XmlNamedStoredProcedureQuery xmlNamedQuery);
		40
		41	OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter(
		42	OrmNamedStoredProcedureQuery2_1 parent,
		43	XmlStoredProcedureParameter xmlParameter);
31	}	44	}

Lines 116-121 Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/NamedStoredProcedureQuery2_1Annotation.java (+10 lines)
116	/**	116	/**
117	* Corresponds to the 'resultClasses' element of the NamedStoredProcedureQuery annotation.	117	* Corresponds to the 'resultClasses' element of the NamedStoredProcedureQuery annotation.
118	*/	118	*/
		119	void addResultClass(int index, String resultClass);
		120
		121	/**
		122	* Corresponds to the 'resultClasses' element of the NamedStoredProcedureQuery annotation.
		123	*/
119	void moveResultClass(int targetIndex, int sourceIndex);	124	void moveResultClass(int targetIndex, int sourceIndex);
120		125
121	/**	126	/**
Lines 156-161 Link Here
156	/**	161	/**
157	* Corresponds to the 'resultSetMappings' element of the NamedStoredProcedureQuery annotation.	162	* Corresponds to the 'resultSetMappings' element of the NamedStoredProcedureQuery annotation.
158	*/	163	*/
		164	void addResultSetMapping(int index, String resultSetMapping);
		165
		166	/**
		167	* Corresponds to the 'resultSetMappings' element of the NamedStoredProcedureQuery annotation.
		168	*/
159	void moveResultSetMapping(int targetIndex, int sourceIndex);	169	void moveResultSetMapping(int targetIndex, int sourceIndex);
160		170
161	/**	171	/**




/*******************************************************************************
 * 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;


/**
 * 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 ParameterMode_2_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;

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

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


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

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

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

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




	 * Corresponds to the 'mode' element of the StoredProcedureParameter annotation.
	 * Return null if the element does not exist in the annotation
	 */
	ParameterMode_2_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(ParameterMode_2_1 mode);

	/**
	 * Return the {@link TextRange} for the 'mode' element. If the element 

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

	/**
	 * Corresponds to the 'type' element of the StoredProcedureParameter annotation.
	 * Setting to null will remove the element.
	 */
	void setTypeName(String type);

	/**
	 * Return the {@link TextRange} for the 'type' element. If the element 

Lines 11-19 Link Here

(-)src/org/eclipse/jpt/jpa/eclipselink/core/internal/EclipseLink2_5JpaFactory.java (+21 lines)
11		11
12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;	12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;	13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;
		14	import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
14	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType;	15	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType;
		16	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaNamedStoredProcedureQuery2_1;
		17	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaStoredProcedureParameter2_1;
		18	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
		19	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1;
		20	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
15	import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;	21	import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;
16	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;	22	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;
		23	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
		24	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
17		25
18	/**	26	/**
19	* EclipseLink 2.5 factory	27	* EclipseLink 2.5 factory
Lines 29-32 Link Here
29	public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) {	37	public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) {
30	return new GenericJavaConverterType(parent, jrt);	38	return new GenericJavaConverterType(parent, jrt);
31	}	39	}
		40
		41	public JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1(
		42	JavaQuery parent,
		43	StoredProcedureParameter2_1Annotation parameterAnnotation) {
		44	return new GenericJavaStoredProcedureParameter2_1(parent, parameterAnnotation);
		45	}
		46
		47	public JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1(
		48	JavaQueryContainer2_1 parent,
		49	NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) {
		50	return new GenericJavaNamedStoredProcedureQuery2_1(parent, namedStoredProcedureQueryAnnotation);
		51	}
		52
32	}	53	}

Lines 10-19 Link Here

(-)src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmXml2_5ContextNodeFactory.java (+19 lines)
10	package org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm;	10	package org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm;
11		11
12	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmConverterType;	12	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmConverterType;
		13	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmNamedStoredProcedureQuery2_1;
		14	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmStoredProcedureParameter2_1;
		15	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1;
		16	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
		17	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1;
13	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.EntityMappings2_1;	18	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.EntityMappings2_1;
14	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1;	19	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1;
15	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory;	20	import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory;
16	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;	21	import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;
		22	import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
		23	import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;
17		24
18	public class EclipseLinkOrmXml2_5ContextNodeFactory	25	public class EclipseLinkOrmXml2_5ContextNodeFactory
19	extends EclipseLinkOrmXml2_4ContextNodeFactory	26	extends EclipseLinkOrmXml2_4ContextNodeFactory
Lines 22-25 Link Here
22	public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) {	29	public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) {
23	return new GenericOrmConverterType(parent, xmlConverter);	30	return new GenericOrmConverterType(parent, xmlConverter);
24	}	31	}
		32
		33	public OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1(
		34	OrmQueryContainer2_1 parent,
		35	XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) {
		36	return new GenericOrmNamedStoredProcedureQuery2_1(parent, xmlNamedStoredProcedureQuery);
		37	}
		38
		39	public OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter(
		40	OrmNamedStoredProcedureQuery2_1 parent,
		41	XmlStoredProcedureParameter xmlParameter) {
		42	return new GenericOrmStoredProcedureParameter2_1(parent, xmlParameter);
		43	}
25	}	44	}

Lines 20-25 Link Here

(-)src/org/eclipse/jpt/jpa/core/tests/internal/context/JptJpaCoreContextModelTests.java (+4 lines)
20	import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.orm.Generic2_0OrmContextModelTests;	20	import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.orm.Generic2_0OrmContextModelTests;
21	import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.persistence.Generic2_0PersistenceContextModelTests;	21	import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.persistence.Generic2_0PersistenceContextModelTests;
22	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.JpaProject2_1Tests;	22	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.JpaProject2_1Tests;
		23	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.java.Generic2_1JavaContextModelTests;
		24	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.orm.Generic2_1OrmContextModelTests;
23	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.persistence.JptJpa2_1ContextPersistenceModelTests;	25	import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.persistence.JptJpa2_1ContextPersistenceModelTests;
24		26
25	/**	27	/**
Lines 43-48 Link Here
43	suite.addTest(Generic2_0OrmContextModelTests.suite());	45	suite.addTest(Generic2_0OrmContextModelTests.suite());
44	suite.addTest(Generic2_0PersistenceContextModelTests.suite());	46	suite.addTest(Generic2_0PersistenceContextModelTests.suite());
45	suite.addTest(JptJpa2_1ContextPersistenceModelTests.suite());	47	suite.addTest(JptJpa2_1ContextPersistenceModelTests.suite());
		48	suite.addTest(Generic2_1JavaContextModelTests.suite());
		49	suite.addTest(Generic2_1OrmContextModelTests.suite());
46	} else {	50	} else {
47	suite.addTest(TestSuite.warning(JptJpaCoreTests.buildMissingJarErrorMessage()));	51	suite.addTest(TestSuite.warning(JptJpaCoreTests.buildMissingJarErrorMessage()));
48	}	52	}

Lines 38-44 Link Here

(-)src/org/eclipse/jpt/jpa/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java (-1 / +1 lines)
38	return suite;	38	return suite;
39	}	39	}
40		40
41	private Generic2_0JavaContextModelTests() {	41	protected Generic2_0JavaContextModelTests() {
42	super();	42	super();
43	throw new UnsupportedOperationException();	43	throw new UnsupportedOperationException();
44	}	44	}

Lines 13-19 Link Here

(-)src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/Generic2_1ContextModelTestCase.java (-1 / +2 lines)
13	import org.eclipse.jpt.jpa.core.jpa2_1.JpaProject2_1;	13	import org.eclipse.jpt.jpa.core.jpa2_1.JpaProject2_1;
14	import org.eclipse.jpt.jpa.core.tests.internal.context.ContextModelTestCase;	14	import org.eclipse.jpt.jpa.core.tests.internal.context.ContextModelTestCase;
15		15
16	public abstract class Generic2_1ContextModelTestCase extends ContextModelTestCase	16	public abstract class Generic2_1ContextModelTestCase
		17	extends ContextModelTestCase
17	{	18	{
18	protected Generic2_1ContextModelTestCase(String name) {	19	protected Generic2_1ContextModelTestCase(String name) {
19	super(name);	20	super(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.tests.internal.jpa2_1.context.java;

import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.java.Generic2_0JavaContextModelTests;

public class Generic2_1JavaContextModelTests
	extends Generic2_0JavaContextModelTests
{
	public static Test suite() {
		TestSuite suite = new TestSuite(Generic2_1JavaContextModelTests.class.getPackage().getName());
		suite.addTestSuite(GenericJavaNamedStoredProcedureQuery2_1Tests.class);
		suite.addTestSuite(GenericJavaStoredProcedureParameter2_1Tests.class);
	return suite;
	}

	private Generic2_1JavaContextModelTests() {
		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.context.java;

import java.util.Iterator;
import java.util.ListIterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.AstNodeType;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.context.QueryHint;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.resource.java.JPA;
import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase;

public class GenericJavaNamedStoredProcedureQuery2_1Tests
	extends Generic2_1ContextModelTestCase
{
	public GenericJavaNamedStoredProcedureQuery2_1Tests(String name) {
		super(name);
	}


	private static final String QUERY_NAME = "QUERY_NAME";
	private static final String PROCEDURE_NAME = "MY_PROCEDURE";
		
	private ICompilationUnit createTestEntityWithNamedStoredProcedureQuery() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return IteratorTools.iterator(JPA.ENTITY, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@Entity").append(CR);
				sb.append("@NamedStoredProcedureQuery(name=\"" + QUERY_NAME + "\", procedureName=\"" + PROCEDURE_NAME + "\")");
			}
		});
	}


	// ********** name ***********
	
	public void testUpdateName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));

		assertEquals(QUERY_NAME, procedureQueryAnnotation.getName());
		assertEquals(QUERY_NAME, procedureQuery.getName());

		//set name to null in the resource model
		procedureQueryAnnotation.setName(null);
		getJpaProject().synchronizeContextModel();
		assertNull(procedureQueryAnnotation.getName());
		assertNull(procedureQuery.getName());

		//set name in the resource model, verify context model updated
		procedureQueryAnnotation.setName("foo");
		getJpaProject().synchronizeContextModel();
		assertEquals("foo", procedureQueryAnnotation.getName());
		assertEquals("foo", procedureQuery.getName());
	}
	
	public void testModifyName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));

		assertEquals(QUERY_NAME, procedureQueryAnnotation.getName());
		assertEquals(QUERY_NAME, procedureQuery.getName());
				
		//set name to null in the context model
		procedureQuery.setName(null);
		assertNull(procedureQueryAnnotation.getName());
		assertNull(procedureQuery.getName());

		//set name in the context model, verify resource model updated
		procedureQuery.setName("foo");
		assertEquals("foo", procedureQueryAnnotation.getName());
		assertEquals("foo", procedureQuery.getName());
	}
	
	// ********** procedure name ***********
	
	public void testUpdateProcedureName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));

		assertEquals(PROCEDURE_NAME, procedureQueryAnnotation.getProcedureName());
		assertEquals(PROCEDURE_NAME, procedureQuery.getProcedureName());

		//set procedure name to null in the resource model
		procedureQueryAnnotation.setProcedureName(null);
		getJpaProject().synchronizeContextModel();
		assertNull(procedureQueryAnnotation.getProcedureName());
		assertNull(procedureQuery.getProcedureName());

		//set procedure name in the resource model, verify context model updated
		procedureQueryAnnotation.setProcedureName("foo");
		getJpaProject().synchronizeContextModel();
		assertEquals("foo", procedureQueryAnnotation.getProcedureName());
		assertEquals("foo", procedureQuery.getProcedureName());
	}
	
	public void testModifyProcedureName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));

		assertEquals(PROCEDURE_NAME, procedureQueryAnnotation.getProcedureName());
		assertEquals(PROCEDURE_NAME, procedureQuery.getProcedureName());
				
		//set procedure name to null in the context model
		procedureQuery.setProcedureName(null);
		assertNull(procedureQueryAnnotation.getProcedureName());
		assertNull(procedureQuery.getProcedureName());

		//set procedure name in the context model, verify resource model updated
		procedureQuery.setProcedureName("foo");
		assertEquals("foo", procedureQueryAnnotation.getProcedureName());
		assertEquals("foo", procedureQuery.getProcedureName());
	}


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

	public void testAddParameter() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	
		
		StoredProcedureParameter2_1 parameter1 = procedureQuery.addParameter(0);
		parameter1.setName("FOO");

		assertEquals("FOO", procedureQueryAnnotation.parameterAt(0).getName());
		
		StoredProcedureParameter2_1 parameter2 = procedureQuery.addParameter(0);
		parameter2.setName("BAR");
		
		assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName());
		assertEquals("FOO", procedureQueryAnnotation.parameterAt(1).getName());
		
		StoredProcedureParameter2_1 parameter3 = procedureQuery.addParameter(1);
		parameter3.setName("BAZ");
		
		assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName());
		
		ListIterator<? extends StoredProcedureParameter2_1> parameters = procedureQuery.getParameters().iterator();
		assertEquals(parameter2, parameters.next());
		assertEquals(parameter3, parameters.next());
		assertEquals(parameter1, parameters.next());
		
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
	}
	
	public void testRemoveParameter() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	

		procedureQuery.addParameter(0).setName("FOO");
		procedureQuery.addParameter(1).setName("BAR");
		procedureQuery.addParameter(2).setName("BAZ");
		
		assertEquals(3, procedureQueryAnnotation.getParametersSize());
		
		procedureQuery.removeParameter(0);
		assertEquals(2, procedureQueryAnnotation.getParametersSize());
		assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName());

		procedureQuery.removeParameter(0);
		assertEquals(1, procedureQueryAnnotation.getParametersSize());
		assertEquals("BAZ", procedureQueryAnnotation.parameterAt(0).getName());
		
		procedureQuery.removeParameter(0);
		assertEquals(0, procedureQueryAnnotation.getParametersSize());
	}
	
	public void testMoveParameter() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	

		procedureQuery.addParameter(0).setName("FOO");
		procedureQuery.addParameter(1).setName("BAR");
		procedureQuery.addParameter(2).setName("BAZ");
		
		assertEquals(3, procedureQueryAnnotation.getParametersSize());
		
		
		procedureQuery.moveParameter(2, 0);
		ListIterator<? extends StoredProcedureParameter2_1> parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());

		assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName());


		procedureQuery.moveParameter(0, 1);
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());

		assertEquals("BAZ", procedureQueryAnnotation.parameterAt(0).getName());
		assertEquals("BAR", procedureQueryAnnotation.parameterAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName());
	}
	
	public void testUpdateParameters() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	
		
		procedureQueryAnnotation.addParameter(0).setName("FOO");
		procedureQueryAnnotation.addParameter(1).setName("BAR");
		procedureQueryAnnotation.addParameter(2).setName("BAZ");
		getJpaProject().synchronizeContextModel();
	
		ListIterator<? extends StoredProcedureParameter2_1> parameters = procedureQuery.getParameters().iterator();
		assertEquals("FOO", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertFalse(parameters.hasNext());
		
		procedureQueryAnnotation.moveParameter(2, 0);
		getJpaProject().synchronizeContextModel();
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());
	
		procedureQueryAnnotation.moveParameter(0, 1);
		getJpaProject().synchronizeContextModel();
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());
	
		procedureQueryAnnotation.removeParameter(1);
		getJpaProject().synchronizeContextModel();
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());
	
		procedureQueryAnnotation.removeParameter(1);
		getJpaProject().synchronizeContextModel();
		parameters = procedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertFalse(parameters.hasNext());
		
		procedureQueryAnnotation.removeParameter(0);
		getJpaProject().synchronizeContextModel();
		assertFalse(procedureQuery.getParameters().iterator().hasNext());
	}

	public void testParametersSize() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();
		assertEquals(0, procedureQuery.getParametersSize());

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	

		procedureQueryAnnotation.addParameter(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(1, procedureQuery.getParametersSize());
		
		procedureQueryAnnotation.addParameter(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(2, procedureQuery.getParametersSize());
		
		procedureQueryAnnotation.removeParameter(0);
		procedureQueryAnnotation.removeParameter(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(0, procedureQuery.getParametersSize());
	}
	
	// ********** result classes **********
	
	public void testAddResultClass() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		
		
		procedureQuery.addResultClass("Employee");
		assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0));
		
		procedureQuery.addResultClass("Address");
		assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0));
		assertEquals("Address", procedureQueryAnnotation.resultClassAt(1));
		
		procedureQuery.addResultClass(1, "Project");
		assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultClassAt(1));
		assertEquals("Address", procedureQueryAnnotation.resultClassAt(2));
		
		ListIterator<String> resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Employee", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertEquals("Address", resultClasses.next());
	}
	
	public void testRemoveResultClass() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultClass("Employee");
		procedureQuery.addResultClass("Address");
		procedureQuery.addResultClass("Project");
		
		assertEquals(3, procedureQueryAnnotation.getResultClassesSize());
		
		procedureQuery.removeResultClass(0);
		assertEquals(2, procedureQueryAnnotation.getResultClassesSize());
		assertEquals("Address", procedureQueryAnnotation.resultClassAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultClassAt(1));

		procedureQuery.removeResultClass("Project");
		assertEquals(1, procedureQueryAnnotation.getResultClassesSize());
		assertEquals("Address", procedureQueryAnnotation.resultClassAt(0));
		
		procedureQuery.removeResultClass(0);
		assertEquals(0, procedureQueryAnnotation.getResultClassesSize());
	}
	
	public void testMoveResultClass() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultClass("Employee");
		procedureQuery.addResultClass("Address");
		procedureQuery.addResultClass("Project");
			
		assertEquals(3, procedureQueryAnnotation.getResultClassesSize());
		
		procedureQuery.moveResultClass(2, 0);
		ListIterator<String> resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());

		assertEquals("Address", procedureQueryAnnotation.resultClassAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultClassAt(1));
		assertEquals("Employee", procedureQueryAnnotation.resultClassAt(2));

		procedureQuery.moveResultClass(0, 1);
		resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Employee", resultClasses.next());

		assertEquals("Project", procedureQueryAnnotation.resultClassAt(0));
		assertEquals("Address", procedureQueryAnnotation.resultClassAt(1));
		assertEquals("Employee", procedureQueryAnnotation.resultClassAt(2));
	}
	
	public void testUpdateResultClass() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultClass("Employee");
		procedureQuery.addResultClass("Address");
		procedureQuery.addResultClass("Project");
		getJpaProject().synchronizeContextModel();
	
		ListIterator<String> resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Employee", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertFalse(resultClasses.hasNext());
		
		procedureQueryAnnotation.moveResultClass(2, 0);
		getJpaProject().synchronizeContextModel();
		resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());
	
		procedureQueryAnnotation.moveResultClass(0, 1);
		getJpaProject().synchronizeContextModel();
		resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());
	
		procedureQueryAnnotation.removeResultClass(1);
		getJpaProject().synchronizeContextModel();
		resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());
	
		procedureQueryAnnotation.removeResultClass(1);
		getJpaProject().synchronizeContextModel();
		resultClasses = procedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertFalse(resultClasses.hasNext());
		
		procedureQueryAnnotation.removeResultClass(0);
		getJpaProject().synchronizeContextModel();
		assertFalse(procedureQuery.getResultClasses().iterator().hasNext());
	}

	public void testResultClassesSize() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();
		assertEquals(0, procedureQuery.getResultClassesSize());
		
		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		
		procedureQueryAnnotation.addResultClass("Employee");
		getJpaProject().synchronizeContextModel();
		assertEquals(1, procedureQuery.getResultClassesSize());
		
		procedureQueryAnnotation.addResultClass(0, "Address");
		getJpaProject().synchronizeContextModel();
		assertEquals(2, procedureQuery.getResultClassesSize());
		
		procedureQueryAnnotation.removeResultClass(0);
		procedureQueryAnnotation.removeResultClass(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(0, procedureQuery.getResultClassesSize());
	}

	// ********** result set mappings **********
		
	public void testAddResultSetMapping() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		
		
		procedureQuery.addResultSetMapping("Employee");
		assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0));
		
		procedureQuery.addResultSetMapping("Address");
		assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0));
		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(1));
		
		procedureQuery.addResultSetMapping(1, "Project");
		assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1));
		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(2));
		
		ListIterator<String> resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Employee", resultSetMapping.next());
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Address", resultSetMapping.next());
	}
	
	public void testRemoveResultSetMapping() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultSetMapping("Employee");
		procedureQuery.addResultSetMapping("Address");
		procedureQuery.addResultSetMapping("Project");
		
		assertEquals(3, procedureQueryAnnotation.getResultSetMappingsSize());
		
		procedureQuery.removeResultSetMapping(0);
		assertEquals(2, procedureQueryAnnotation.getResultSetMappingsSize());
		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1));

		procedureQuery.removeResultSetMapping("Project");
		assertEquals(1, procedureQueryAnnotation.getResultSetMappingsSize());
		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0));
		
		procedureQuery.removeResultSetMapping(0);
		assertEquals(0, procedureQueryAnnotation.getResultSetMappingsSize());
	}
	
	public void testMoveResultSetMapping() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultSetMapping("Employee");
		procedureQuery.addResultSetMapping("Address");
		procedureQuery.addResultSetMapping("Project");
			
		assertEquals(3, procedureQueryAnnotation.getResultSetMappingsSize());
		
		procedureQuery.moveResultSetMapping(2, 0);
		ListIterator<String> resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Address", resultSetMapping.next());
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Employee", resultSetMapping.next());

		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0));
		assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1));
		assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(2));

		procedureQuery.moveResultSetMapping(0, 1);
		resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Address", resultSetMapping.next());
		assertEquals("Employee", resultSetMapping.next());

		assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(0));
		assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(1));
		assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(2));
	}
	
	public void testUpdateResultSetMapping() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addResultSetMapping("Employee");
		procedureQuery.addResultSetMapping("Address");
		procedureQuery.addResultSetMapping("Project");
		getJpaProject().synchronizeContextModel();
	
		ListIterator<String> resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Employee", resultSetMapping.next());
		assertEquals("Address", resultSetMapping.next());
		assertEquals("Project", resultSetMapping.next());
		assertFalse(resultSetMapping.hasNext());
		
		procedureQueryAnnotation.moveResultSetMapping(2, 0);
		getJpaProject().synchronizeContextModel();
		resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Address", resultSetMapping.next());
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Employee", resultSetMapping.next());
		assertFalse(resultSetMapping.hasNext());
	
		procedureQueryAnnotation.moveResultSetMapping(0, 1);
		getJpaProject().synchronizeContextModel();
		resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Address", resultSetMapping.next());
		assertEquals("Employee", resultSetMapping.next());
		assertFalse(resultSetMapping.hasNext());
	
		procedureQueryAnnotation.removeResultSetMapping(1);
		getJpaProject().synchronizeContextModel();
		resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMapping.next());
		assertEquals("Employee", resultSetMapping.next());
		assertFalse(resultSetMapping.hasNext());
	
		procedureQueryAnnotation.removeResultSetMapping(1);
		getJpaProject().synchronizeContextModel();
		resultSetMapping = procedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMapping.next());
		assertFalse(resultSetMapping.hasNext());
		
		procedureQueryAnnotation.removeResultSetMapping(0);
		getJpaProject().synchronizeContextModel();
		assertFalse(procedureQuery.getResultSetMappings().iterator().hasNext());
	}

	public void testResultSetMappingsSize() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();
		assertEquals(0, procedureQuery.getResultSetMappingsSize());
		
		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		
		procedureQueryAnnotation.addResultSetMapping("Employee");
		getJpaProject().synchronizeContextModel();
		assertEquals(1, procedureQuery.getResultSetMappingsSize());
		
		procedureQueryAnnotation.addResultSetMapping(0, "Address");
		getJpaProject().synchronizeContextModel();
		assertEquals(2, procedureQuery.getResultSetMappingsSize());
		
		procedureQueryAnnotation.removeResultSetMapping(0);
		procedureQueryAnnotation.removeResultSetMapping(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(0, procedureQuery.getResultSetMappingsSize());
	}
	
	// ************ hints ************
	
	public void testAddHint() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));	
		
		QueryHint queryHint = procedureQuery.addHint(0);
		queryHint.setName("FOO");

		assertEquals("FOO", procedureQueryAnnotation.hintAt(0).getName());
		
		QueryHint queryHint2 = procedureQuery.addHint(0);
		queryHint2.setName("BAR");
		
		assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName());
		assertEquals("FOO", procedureQueryAnnotation.hintAt(1).getName());
		
		QueryHint queryHint3 = procedureQuery.addHint(1);
		queryHint3.setName("BAZ");
		
		assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName());
		
		ListIterator<? extends QueryHint> hints = procedureQuery.getHints().iterator();
		assertEquals(queryHint2, hints.next());
		assertEquals(queryHint3, hints.next());
		assertEquals(queryHint, hints.next());
		
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
	}
	
	public void testRemoveHint() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addHint(0).setName("FOO");
		procedureQuery.addHint(1).setName("BAR");
		procedureQuery.addHint(2).setName("BAZ");
		
		assertEquals(3, procedureQueryAnnotation.getHintsSize());
		
		procedureQuery.removeHint(0);
		assertEquals(2, procedureQueryAnnotation.getHintsSize());
		assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName());

		procedureQuery.removeHint(0);
		assertEquals(1, procedureQueryAnnotation.getHintsSize());
		assertEquals("BAZ", procedureQueryAnnotation.hintAt(0).getName());
		
		procedureQuery.removeHint(0);
		assertEquals(0, procedureQueryAnnotation.getHintsSize());
	}
	
	public void testMoveHint() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		

		procedureQuery.addHint(0).setName("FOO");
		procedureQuery.addHint(1).setName("BAR");
		procedureQuery.addHint(2).setName("BAZ");
		
		assertEquals(3, procedureQueryAnnotation.getHintsSize());
		
		procedureQuery.moveHint(2, 0);
		ListIterator<? extends QueryHint> hints = procedureQuery.getHints().iterator();
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());

		assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName());
		assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName());


		procedureQuery.moveHint(0, 1);
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("FOO", hints.next().getName());

		assertEquals("BAZ", procedureQueryAnnotation.hintAt(0).getName());
		assertEquals("BAR", procedureQueryAnnotation.hintAt(1).getName());
		assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName());
	}
	
	public void testUpdateHints() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));		
		
		procedureQueryAnnotation.addHint(0).setName("FOO");
		procedureQueryAnnotation.addHint(1).setName("BAR");
		procedureQueryAnnotation.addHint(2).setName("BAZ");
		getJpaProject().synchronizeContextModel();
	
		ListIterator<? extends QueryHint> hints = procedureQuery.getHints().iterator();
		assertEquals("FOO", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertFalse(hints.hasNext());
		
		procedureQueryAnnotation.moveHint(2, 0);
		getJpaProject().synchronizeContextModel();
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());
	
		procedureQueryAnnotation.moveHint(0, 1);
		getJpaProject().synchronizeContextModel();
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());
	
		procedureQueryAnnotation.removeHint(1);
		getJpaProject().synchronizeContextModel();
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());
	
		procedureQueryAnnotation.removeHint(1);
		getJpaProject().synchronizeContextModel();
		hints = procedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertFalse(hints.hasNext());
		
		procedureQueryAnnotation.removeHint(0);
		getJpaProject().synchronizeContextModel();
		assertFalse(procedureQuery.getHints().iterator().hasNext());
	}

	public void testHintsSize() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		Entity entity = getJavaEntity();
		NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next();
		assertEquals(0, procedureQuery.getHintsSize());

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		
		procedureQueryAnnotation.addHint(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(1, procedureQuery.getHintsSize());
		
		procedureQueryAnnotation.addHint(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(2, procedureQuery.getHintsSize());
		
		procedureQueryAnnotation.removeHint(0);
		procedureQueryAnnotation.removeHint(0);
		getJpaProject().synchronizeContextModel();
		assertEquals(0, procedureQuery.getHintsSize());
	}
	
}




/*******************************************************************************
 * 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.context.java;

import java.util.Iterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.AstNodeType;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
import org.eclipse.jpt.jpa.core.context.Entity;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1;
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.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase;

public class GenericJavaStoredProcedureParameter2_1Tests
	extends Generic2_1ContextModelTestCase
{
	public GenericJavaStoredProcedureParameter2_1Tests(String name) {
		super(name);
	}


	private static final String QUERY_NAME = "QUERY_NAME";
		
	private ICompilationUnit createTestEntityWithNamedStoredProcedureQuery() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return IteratorTools.iterator(JPA.ENTITY, JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@Entity").append(CR);
				sb.append("@NamedStoredProcedureQuery(name=\"" + QUERY_NAME + "\", parameters=@StoredProcedureParameter())");
			}
		});
	}
	
	// ************ name ***********
	
	public void testUpdateName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getName());
		assertNull(parameter.getName());

		//set name in the resource model, verify context model updated
		parameterAnnotation.setName("foo");
		getJpaProject().synchronizeContextModel();
		assertEquals("foo", parameterAnnotation.getName());
		assertEquals("foo", parameter.getName());
		
		//set name to null in the resource model
		parameterAnnotation.setName(null); 
		getJpaProject().synchronizeContextModel();
		assertNull(parameter.getName());
	}
	
	public void testModifyName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getName());
		assertNull(parameter.getName());

		//set name in the context model, verify resource model updated
		parameter.setName("foo");
		assertEquals("foo", parameterAnnotation.getName());
		assertEquals("foo", parameter.getName());
		
		//set name to null in the context model
		parameter.setName(null);
		assertNull(parameterAnnotation.getName());
		assertNull(parameter.getName());
	}
	
	// ************ mode **********
	
	public void testUpdateMode() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getMode());
		assertNull(parameter.getSpecifiedMode());
		assertEquals(ParameterMode2_1.IN, parameter.getMode());

		//set mode in the resource model, verify context model updated
		parameterAnnotation.setMode(ParameterMode_2_1.IN);
		getJpaProject().synchronizeContextModel();
		assertEquals(ParameterMode_2_1.IN, parameterAnnotation.getMode());
		assertEquals(ParameterMode2_1.IN, parameter.getMode());
		
		//set name to null in the resource model
		parameterAnnotation.setMode(null); 
		getJpaProject().synchronizeContextModel();
		assertNull(parameterAnnotation.getMode());
		assertNull(parameter.getSpecifiedMode());
		assertEquals(ParameterMode2_1.IN, parameter.getMode());

	}
	
	public void testModifyMode() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getMode());
		assertNull(parameter.getSpecifiedMode());
		assertEquals(ParameterMode2_1.IN, parameter.getMode());

		//set mode in the context model, verify resource model updated
		parameter.setSpecifiedMode(ParameterMode2_1.INOUT);
		assertEquals(ParameterMode_2_1.INOUT, parameterAnnotation.getMode());
		assertEquals(ParameterMode2_1.INOUT, parameter.getMode());
		
		//set mode to null in the context model
		parameter.setSpecifiedMode(null);
		assertNull(parameterAnnotation.getMode());
		assertNull(parameter.getSpecifiedMode());
		assertEquals(ParameterMode2_1.IN, parameter.getMode());

	}

	// ************ type name **********
	
	public void testUpdateTypeName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getTypeName());
		assertNull(parameter.getTypeName());

		//set type in the resource model, verify context model updated
		parameterAnnotation.setTypeName("Foo");
		getJpaProject().synchronizeContextModel();
		assertEquals("Foo", parameterAnnotation.getTypeName());
		assertEquals("Foo", parameter.getTypeName());
		
		//set type to null in the resource model
		parameterAnnotation.setTypeName(null);
		getJpaProject().synchronizeContextModel();
		assertNull(parameter.getTypeName());
	}
	
	public void testModifyTypeName() throws Exception {
		createTestEntityWithNamedStoredProcedureQuery();
		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
		
		Entity entity = getJavaEntity();
		StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next();

		JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE);
		NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME));
		StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next();
		
		assertNull(parameterAnnotation.getTypeName());
		assertNull(parameter.getTypeName());

		//set type in the context model, verify resource model updated
		parameter.setTypeName("Foo");
		assertEquals("Foo", parameterAnnotation.getTypeName());
		assertEquals("Foo", parameter.getTypeName());
		
		//set type to null in the context model
		parameter.setTypeName(null);
		assertNull(parameterAnnotation.getTypeName());
		assertNull(parameter.getTypeName());
	}

}




/*******************************************************************************
 * 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.context.orm;

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

public class Generic2_1OrmContextModelTests extends TestCase
{

	public static Test suite() {
		TestSuite suite = new TestSuite(Generic2_1OrmContextModelTests.class.getPackage().getName());

		suite.addTestSuite(GenericOrmNamedStoredProcedureQuery2_1Tests.class);
		suite.addTestSuite(GenericOrmStoredProcedureParameter2_1Tests.class);

		return suite;
	}

	private Generic2_1OrmContextModelTests() {
		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.context.orm;

import java.util.ListIterator;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
import org.eclipse.jpt.jpa.core.context.orm.OrmQueryHint;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
import org.eclipse.jpt.jpa.core.resource.orm.XmlEntityMappings;
import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery;
import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory;
import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef;
import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase;

public class GenericOrmNamedStoredProcedureQuery2_1Tests
	extends Generic2_1ContextModelTestCase
{
	public GenericOrmNamedStoredProcedureQuery2_1Tests(String name) {
		super(name);
	}
	
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef();
		mappingFileRef.setFileName(XmlEntityMappings.DEFAULT_RUNTIME_PATH_NAME);
		getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef);
		getPersistenceXmlResource().save(null);
	}

	// *********** name *********
	
	public void testUpdateName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);
		
		assertNull(ormProcedureQuery.getName());
		assertNull(procedureQueryResource.getName());
				
		//set name in the resource model, verify context model updated
		procedureQueryResource.setName("foo");
		assertEquals("foo", ormProcedureQuery.getName());
		assertEquals("foo", procedureQueryResource.getName());
	
		//set name to null in the resource model
		procedureQueryResource.setName(null);
		assertNull(ormProcedureQuery.getName());
		assertNull(procedureQueryResource.getName());
	}
	
	public void testModifyName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);
		
		assertNull(ormProcedureQuery.getName());
		assertNull(procedureQueryResource.getName());
				
		//set name in the context model, verify resource model updated
		ormProcedureQuery.setName("foo");
		assertEquals("foo", ormProcedureQuery.getName());
		assertEquals("foo", procedureQueryResource.getName());
	
		//set new name in the context model, verify resource model updated
		ormProcedureQuery.setName("newFoo");
		assertEquals("newFoo", ormProcedureQuery.getName());
		assertEquals("newFoo", procedureQueryResource.getName());

		//set name to null in the context model
		ormProcedureQuery.setName(null);
		assertNull(ormProcedureQuery.getName());
		assertNull(procedureQueryResource.getName());
	}
	
	// ********** procedure name ***********
	
	public void testUpdateProcedureName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);
		
		assertNull(ormProcedureQuery.getProcedureName());
		assertNull(procedureQueryResource.getProcedureName());
				
		//set procedure name in the resource model, verify context model updated
		procedureQueryResource.setProcedureName("foo");
		assertEquals("foo", ormProcedureQuery.getProcedureName());
		assertEquals("foo", procedureQueryResource.getProcedureName());
	
		//set procedure name to null in the resource model
		procedureQueryResource.setProcedureName(null);
		assertNull(ormProcedureQuery.getProcedureName());
		assertNull(procedureQueryResource.getProcedureName());
	}
	
	public void testModifyProcedureName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);
		
		assertNull(ormProcedureQuery.getProcedureName());
		assertNull(procedureQueryResource.getName());
				
		//set procedure name in the context model, verify resource model updated
		ormProcedureQuery.setProcedureName("foo");
		assertEquals("foo", ormProcedureQuery.getProcedureName());
		assertEquals("foo", procedureQueryResource.getProcedureName());
	
		//set new procedure name in the context model, verify resource model updated
		ormProcedureQuery.setProcedureName("newFoo");
		assertEquals("newFoo", ormProcedureQuery.getProcedureName());
		assertEquals("newFoo", procedureQueryResource.getProcedureName());

		//set procedure name to null in the context model
		ormProcedureQuery.setProcedureName(null);
		assertNull(ormProcedureQuery.getProcedureName());
		assertNull(procedureQueryResource.getProcedureName());
	}
	
	
	// ************ parameters ************
	
	public void testAddParameter() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		OrmStoredProcedureParameter2_1 parameter1 = ormProcedureQuery.addParameter(0);
		parameter1.setName("FOO");
				
		assertEquals("FOO", procedureQueryResource.getParameters().get(0).getName());
		
		OrmStoredProcedureParameter2_1 parameter2 = ormProcedureQuery.addParameter(0);
		parameter2.setName("BAR");
		
		assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName());
		assertEquals("FOO", procedureQueryResource.getParameters().get(1).getName());
		
		OrmStoredProcedureParameter2_1 parameter3 = ormProcedureQuery.addParameter(1);
		parameter3.setName("BAZ");
		
		assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName());
		
		ListIterator<OrmStoredProcedureParameter2_1> parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals(parameter2, parameters.next());
		assertEquals(parameter3, parameters.next());
		assertEquals(parameter1, parameters.next());
		
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
	}
	
	public void testRemoveParameter() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addParameter(0).setName("FOO");
		ormProcedureQuery.addParameter(1).setName("BAR");
		ormProcedureQuery.addParameter(2).setName("BAZ");
		
		assertEquals(3, procedureQueryResource.getParameters().size());
		
		ormProcedureQuery.removeParameter(0);
		assertEquals(2, procedureQueryResource.getParameters().size());
		assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName());

		ormProcedureQuery.removeParameter(0);
		assertEquals(1, procedureQueryResource.getParameters().size());
		assertEquals("BAZ", procedureQueryResource.getParameters().get(0).getName());
		
		ormProcedureQuery.removeParameter(0);
		assertEquals(0, procedureQueryResource.getParameters().size());
	}
	
	public void testMoveParameter() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addParameter(0).setName("FOO");
		ormProcedureQuery.addParameter(1).setName("BAR");
		ormProcedureQuery.addParameter(2).setName("BAZ");
		
		assertEquals(3, procedureQueryResource.getParameters().size());
		
		ormProcedureQuery.moveParameter(2, 0);
		ListIterator<OrmStoredProcedureParameter2_1> parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());

		assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName());


		ormProcedureQuery.moveParameter(0, 1);
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());

		assertEquals("BAZ", procedureQueryResource.getParameters().get(0).getName());
		assertEquals("BAR", procedureQueryResource.getParameters().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName());
	}
	
	public void testUpdateParameters() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter());
		procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter());
		procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter());
		
		procedureQueryResource.getParameters().get(0).setName("FOO");
		procedureQueryResource.getParameters().get(1).setName("BAR");
		procedureQueryResource.getParameters().get(2).setName("BAZ");

		ListIterator<OrmStoredProcedureParameter2_1> parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("FOO", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertFalse(parameters.hasNext());
		
		procedureQueryResource.getParameters().move(2, 0);
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAR", parameters.next().getName());
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());

		procedureQueryResource.getParameters().move(0, 1);
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("BAR", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());

		procedureQueryResource.getParameters().remove(1);
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertEquals("FOO", parameters.next().getName());
		assertFalse(parameters.hasNext());

		procedureQueryResource.getParameters().remove(1);
		parameters = ormProcedureQuery.getParameters().iterator();
		assertEquals("BAZ", parameters.next().getName());
		assertFalse(parameters.hasNext());
		
		procedureQueryResource.getParameters().remove(0);
		assertFalse(ormProcedureQuery.getParameters().iterator().hasNext());
	}
	
	
	// ************ result classes ********
	
	public void testAddResultClass() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultClass("Employee");
		assertEquals("Employee", procedureQueryResource.getResultClasses().get(0));
		
		ormProcedureQuery.addResultClass("Address");
		assertEquals("Employee", procedureQueryResource.getResultClasses().get(0));
		assertEquals("Address", procedureQueryResource.getResultClasses().get(1));
		
		ormProcedureQuery.addResultClass(1, "Project");
		
		assertEquals("Employee", procedureQueryResource.getResultClasses().get(0));
		assertEquals("Project", procedureQueryResource.getResultClasses().get(1));
		assertEquals("Address", procedureQueryResource.getResultClasses().get(2));
		
		ListIterator<String> resultSetClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Employee", resultSetClasses.next());
		assertEquals("Project", resultSetClasses.next());
		assertEquals("Address", resultSetClasses.next());
	}
	
	public void testRemoveResultClass() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultClass("Employee");
		ormProcedureQuery.addResultClass("Address");
		ormProcedureQuery.addResultClass("Project");
		
		assertEquals(3, procedureQueryResource.getResultClasses().size());
		
		ormProcedureQuery.removeResultClass(0);
		assertEquals(2, procedureQueryResource.getResultClasses().size());
		assertEquals("Address", procedureQueryResource.getResultClasses().get(0));
		assertEquals("Project", procedureQueryResource.getResultClasses().get(1));

		ormProcedureQuery.removeResultClass("Project");
		assertEquals(1, procedureQueryResource.getResultClasses().size());
		assertEquals("Address", procedureQueryResource.getResultClasses().get(0));
		
		ormProcedureQuery.removeResultClass(0);
		assertEquals(0, procedureQueryResource.getResultClasses().size());
	}
	
	public void testMoveResultClass() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultClass("Employee");
		ormProcedureQuery.addResultClass("Address");
		ormProcedureQuery.addResultClass("Project");
		
		assertEquals(3, procedureQueryResource.getResultClasses().size());
		
		ormProcedureQuery.moveResultClass(2, 0);
		ListIterator<String> resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());

		assertEquals("Address", procedureQueryResource.getResultClasses().get(0));
		assertEquals("Project", procedureQueryResource.getResultClasses().get(1));
		assertEquals("Employee", procedureQueryResource.getResultClasses().get(2));

		ormProcedureQuery.moveResultClass(0, 1);
		resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Employee", resultClasses.next());

		assertEquals("Project", procedureQueryResource.getResultClasses().get(0));
		assertEquals("Address", procedureQueryResource.getResultClasses().get(1));
		assertEquals("Employee", procedureQueryResource.getResultClasses().get(2));
	}
	
	public void testUpdateResultClasses() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		procedureQueryResource.getResultClasses().add("Employee");
		procedureQueryResource.getResultClasses().add("Address");
		procedureQueryResource.getResultClasses().add("Project");

		ListIterator<String> resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Employee", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertFalse(resultClasses.hasNext());
		
		procedureQueryResource.getResultClasses().move(2, 0);
		resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Address", resultClasses.next());
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());

		procedureQueryResource.getResultClasses().move(0, 1);
		resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Address", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());

		procedureQueryResource.getResultClasses().remove(1);
		resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertEquals("Employee", resultClasses.next());
		assertFalse(resultClasses.hasNext());

		procedureQueryResource.getResultClasses().remove(1);
		resultClasses = ormProcedureQuery.getResultClasses().iterator();
		assertEquals("Project", resultClasses.next());
		assertFalse(resultClasses.hasNext());
		
		procedureQueryResource.getResultClasses().remove(0);
		assertFalse(ormProcedureQuery.getResultClasses().iterator().hasNext());
	}


	// ************ result set mappings ********
	
	public void testAddResultSetMapping() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultSetMapping("Employee");
		assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0));
		
		ormProcedureQuery.addResultSetMapping("Address");
		assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0));
		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(1));
		
		ormProcedureQuery.addResultSetMapping(1, "Project");
		
		assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0));
		assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1));
		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(2));
		
		ListIterator<String> resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Employee", resultSetMappings.next());
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Address", resultSetMappings.next());
	}
	
	public void testRemoveResultSetMapping() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultSetMapping("Employee");
		ormProcedureQuery.addResultSetMapping("Address");
		ormProcedureQuery.addResultSetMapping("Project");
		
		assertEquals(3, procedureQueryResource.getResultSetMappings().size());
		
		ormProcedureQuery.removeResultSetMapping(0);
		assertEquals(2, procedureQueryResource.getResultSetMappings().size());
		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0));
		assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1));

		ormProcedureQuery.removeResultSetMapping("Project");
		assertEquals(1, procedureQueryResource.getResultSetMappings().size());
		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0));
		
		ormProcedureQuery.removeResultSetMapping(0);
		assertEquals(0, procedureQueryResource.getResultSetMappings().size());
	}
	
	public void testMoveResultSetMapping() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addResultSetMapping("Employee");
		ormProcedureQuery.addResultSetMapping("Address");
		ormProcedureQuery.addResultSetMapping("Project");
		
		assertEquals(3, procedureQueryResource.getResultSetMappings().size());
		
		ormProcedureQuery.moveResultSetMapping(2, 0);
		ListIterator<String> resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Address", resultSetMappings.next());
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Employee", resultSetMappings.next());

		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0));
		assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1));
		assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(2));

		ormProcedureQuery.moveResultSetMapping(0, 1);
		resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Address", resultSetMappings.next());
		assertEquals("Employee", resultSetMappings.next());

		assertEquals("Project", procedureQueryResource.getResultSetMappings().get(0));
		assertEquals("Address", procedureQueryResource.getResultSetMappings().get(1));
		assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(2));
	}
	
	public void testUpdateResultSetMappings() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		procedureQueryResource.getResultSetMappings().add("Employee");
		procedureQueryResource.getResultSetMappings().add("Address");
		procedureQueryResource.getResultSetMappings().add("Project");

		ListIterator<String> resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Employee", resultSetMappings.next());
		assertEquals("Address", resultSetMappings.next());
		assertEquals("Project", resultSetMappings.next());
		assertFalse(resultSetMappings.hasNext());
		
		procedureQueryResource.getResultSetMappings().move(2, 0);
		resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Address", resultSetMappings.next());
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Employee", resultSetMappings.next());
		assertFalse(resultSetMappings.hasNext());

		procedureQueryResource.getResultSetMappings().move(0, 1);
		resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Address", resultSetMappings.next());
		assertEquals("Employee", resultSetMappings.next());
		assertFalse(resultSetMappings.hasNext());

		procedureQueryResource.getResultSetMappings().remove(1);
		resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMappings.next());
		assertEquals("Employee", resultSetMappings.next());
		assertFalse(resultSetMappings.hasNext());

		procedureQueryResource.getResultSetMappings().remove(1);
		resultSetMappings= ormProcedureQuery.getResultSetMappings().iterator();
		assertEquals("Project", resultSetMappings.next());
		assertFalse(resultSetMappings.hasNext());
		
		procedureQueryResource.getResultSetMappings().remove(0);
		assertFalse(ormProcedureQuery.getResultSetMappings().iterator().hasNext());
	}
	
	
	// ************ hints **********
	
	public void testAddHint() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		OrmQueryHint queryHint = ormProcedureQuery.addHint(0);
		queryHint.setName("FOO");
				
		assertEquals("FOO", procedureQueryResource.getHints().get(0).getName());
		
		OrmQueryHint queryHint2 = ormProcedureQuery.addHint(0);
		queryHint2.setName("BAR");
		
		assertEquals("BAR", procedureQueryResource.getHints().get(0).getName());
		assertEquals("FOO", procedureQueryResource.getHints().get(1).getName());
		
		OrmQueryHint queryHint3 = ormProcedureQuery.addHint(1);
		queryHint3.setName("BAZ");
		
		assertEquals("BAR", procedureQueryResource.getHints().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getHints().get(2).getName());
		
		ListIterator<OrmQueryHint> queryHints = ormProcedureQuery.getHints().iterator();
		assertEquals(queryHint2, queryHints.next());
		assertEquals(queryHint3, queryHints.next());
		assertEquals(queryHint, queryHints.next());
		
		queryHints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAR", queryHints.next().getName());
		assertEquals("BAZ", queryHints.next().getName());
		assertEquals("FOO", queryHints.next().getName());
	}
	
	public void testRemoveHint() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addHint(0).setName("FOO");
		ormProcedureQuery.addHint(1).setName("BAR");
		ormProcedureQuery.addHint(2).setName("BAZ");
		
		assertEquals(3, procedureQueryResource.getHints().size());
		
		ormProcedureQuery.removeHint(0);
		assertEquals(2, procedureQueryResource.getHints().size());
		assertEquals("BAR", procedureQueryResource.getHints().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName());

		ormProcedureQuery.removeHint(0);
		assertEquals(1, procedureQueryResource.getHints().size());
		assertEquals("BAZ", procedureQueryResource.getHints().get(0).getName());
		
		ormProcedureQuery.removeHint(0);
		assertEquals(0, procedureQueryResource.getHints().size());
	}
	
	public void testMoveHint() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		ormProcedureQuery.addHint(0).setName("FOO");
		ormProcedureQuery.addHint(1).setName("BAR");
		ormProcedureQuery.addHint(2).setName("BAZ");
		
		assertEquals(3, procedureQueryResource.getHints().size());
		
		
		ormProcedureQuery.moveHint(2, 0);
		ListIterator<OrmQueryHint> hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());

		assertEquals("BAR", procedureQueryResource.getHints().get(0).getName());
		assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getHints().get(2).getName());


		ormProcedureQuery.moveHint(0, 1);
		hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("FOO", hints.next().getName());

		assertEquals("BAZ", procedureQueryResource.getHints().get(0).getName());
		assertEquals("BAR", procedureQueryResource.getHints().get(1).getName());
		assertEquals("FOO", procedureQueryResource.getHints().get(2).getName());
	}
	
	public void testUpdateHints() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0);
		
		XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0);

		procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint());
		procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint());
		procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint());
		
		procedureQueryResource.getHints().get(0).setName("FOO");
		procedureQueryResource.getHints().get(1).setName("BAR");
		procedureQueryResource.getHints().get(2).setName("BAZ");

		ListIterator<OrmQueryHint> hints = ormProcedureQuery.getHints().iterator();
		assertEquals("FOO", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertFalse(hints.hasNext());
		
		procedureQueryResource.getHints().move(2, 0);
		hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAR", hints.next().getName());
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());

		procedureQueryResource.getHints().move(0, 1);
		hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("BAR", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());

		procedureQueryResource.getHints().remove(1);
		hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertEquals("FOO", hints.next().getName());
		assertFalse(hints.hasNext());

		procedureQueryResource.getHints().remove(1);
		hints = ormProcedureQuery.getHints().iterator();
		assertEquals("BAZ", hints.next().getName());
		assertFalse(hints.hasNext());
		
		procedureQueryResource.getHints().remove(0);
		assertFalse(ormProcedureQuery.getHints().iterator().hasNext());
	}

}




/*******************************************************************************
 * 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.context.orm;

import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1;
import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1;
import org.eclipse.jpt.jpa.core.resource.orm.XmlEntityMappings;
import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter;
import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1;
import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory;
import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef;
import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase;

public class GenericOrmStoredProcedureParameter2_1Tests
	extends Generic2_1ContextModelTestCase
{
	public GenericOrmStoredProcedureParameter2_1Tests(String name) {
		super(name);
	}
	
	
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef();
		mappingFileRef.setFileName(XmlEntityMappings.DEFAULT_RUNTIME_PATH_NAME);
		getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef);
		getPersistenceXmlResource().save(null);
	}

	// ******* name ***********
	
	public void testUpdateName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getName());
		assertNull(parameterResource.getName());
				
		//set name in the resource model, verify context model updated
		parameterResource.setName("foo");
		assertEquals("foo", ormParameter.getName());
		assertEquals("foo", parameterResource.getName());
	
		//set name to null in the resource model
		parameterResource.setName(null);
		assertNull(ormParameter.getName());
		assertNull(parameterResource.getName());
	}
	
	public void testModifyName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getName());
		assertNull(parameterResource.getName());
				
		//set name in the context model, verify resource model updated
		ormParameter.setName("foo");
		assertEquals("foo", ormParameter.getName());
		assertEquals("foo", parameterResource.getName());
		
		//set new name in the context model, verify resource model updated
		ormParameter.setName("newFoo");
		assertEquals("newFoo", ormParameter.getName());
		assertEquals("newFoo", parameterResource.getName());
	
		//set name to null in the context model
		ormParameter.setName(null);
		assertNull(ormParameter.getName());
		assertNull(parameterResource.getName());
	}
	
	// ********* mode *********
	
	public void testUpdateMode() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getSpecifiedMode());
		// test default mode
		assertEquals(ParameterMode2_1.IN, ormParameter.getMode());
		assertNull(parameterResource.getMode());
				
		//set mode in the resource model, verify context model updated
		parameterResource.setMode(ParameterMode_2_1.INOUT);
		assertEquals(ParameterMode2_1.INOUT, ormParameter.getMode());
		assertEquals(ParameterMode_2_1.INOUT, parameterResource.getMode());
	
		//set mode to null in the resource model
		parameterResource.setMode(null);
		assertNull(ormParameter.getSpecifiedMode());
		// test default mode
		assertEquals(ParameterMode2_1.IN, ormParameter.getMode());
		assertNull(parameterResource.getMode());
	}
	
	public void testModifyMode() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getSpecifiedMode());
		// test default mode
		assertEquals(ParameterMode2_1.IN, ormParameter.getMode());
		assertNull(parameterResource.getMode());
				
		//set mode in the context model, verify resource model updated
		ormParameter.setSpecifiedMode(ParameterMode2_1.INOUT);
		assertEquals(ParameterMode2_1.INOUT, ormParameter.getMode());
		assertEquals(ParameterMode_2_1.INOUT, parameterResource.getMode());
		
		//set new mode in the context model, verify resource model updated
		ormParameter.setSpecifiedMode(ParameterMode2_1.OUT);
		assertEquals(ParameterMode2_1.OUT, ormParameter.getMode());
		assertEquals(ParameterMode_2_1.OUT, parameterResource.getMode());

	
		//set mode to null in the context model
		ormParameter.setSpecifiedMode(null);
		assertNull(ormParameter.getSpecifiedMode());
		// test default mode
		assertEquals(ParameterMode2_1.IN, ormParameter.getMode());
		assertNull(parameterResource.getMode());
	}
	
	// *********** type name *********
	
	public void testUpdateTypeName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getTypeName());
		assertNull(parameterResource.getClassName());
		
		//set type name in the resource model, verify context model updated
		parameterResource.setClassName("MyType");
		assertEquals("MyType", ormParameter.getTypeName());
		assertEquals("MyType", parameterResource.getClassName());
	
		//set type name to null in the resource model
		parameterResource.setClassName(null);
		assertNull(ormParameter.getTypeName());
		assertNull(parameterResource.getClassName());
	}
	
	public void testModifyTypeName() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
		OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0);
		
		XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0);
		
		assertNull(ormParameter.getTypeName());
		assertNull(parameterResource.getClassName());
				
		//set type name in the resource model, verify context model updated
		parameterResource.setClassName("MyType");
		assertEquals("MyType", ormParameter.getTypeName());
		assertEquals("MyType", parameterResource.getClassName());
	
		//set type name in the resource model, verify context model updated
		parameterResource.setClassName("MyNewType");
		assertEquals("MyNewType", ormParameter.getTypeName());
		assertEquals("MyNewType", parameterResource.getClassName());
	
		//set type name to null in the resource model
		parameterResource.setClassName(null);
		assertNull(ormParameter.getTypeName());
		assertNull(parameterResource.getClassName());
	}
}




import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1;
import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;

@SuppressWarnings("nls")

		
		NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals(ParameterMode_2_1.IN, parameter.getMode());
	}

	public void testSetMode() throws Exception {

		
		NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
		StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
		assertEquals(ParameterMode_2_1.IN, parameter.getMode());
		
		parameter.setMode(ParameterMode_2_1.INOUT);
		assertEquals(ParameterMode_2_1.INOUT, parameter.getMode());
		assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = INOUT, type = MyType.class)", cu);
	
		parameter.setMode(null);

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

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

	public void testSetType() throws Exception {

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

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

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

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

		parameter.setTypeName(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 10-24 Link Here

(-)model/src/org/eclipse/jpt/jpa/core/resource/orm/XmlStoredProcedureParameter.java (-11 / +3 lines)
10	package org.eclipse.jpt.jpa.core.resource.orm;	10	package org.eclipse.jpt.jpa.core.resource.orm;
11		11
12	import org.eclipse.emf.common.notify.Notification;	12	import org.eclipse.emf.common.notify.Notification;
13
14	import org.eclipse.emf.ecore.EClass;	13	import org.eclipse.emf.ecore.EClass;
15	import org.eclipse.emf.ecore.EStructuralFeature;	14	import org.eclipse.emf.ecore.EStructuralFeature;
16
17	import org.eclipse.emf.ecore.impl.ENotificationImpl;	15	import org.eclipse.emf.ecore.impl.ENotificationImpl;
18
19	import org.eclipse.jpt.common.core.internal.utility.translators.SimpleTranslator;	16	import org.eclipse.jpt.common.core.internal.utility.translators.SimpleTranslator;
20	import org.eclipse.jpt.common.core.resource.xml.EBaseObjectImpl;	17	import org.eclipse.jpt.common.core.resource.xml.EBaseObjectImpl;
21
22	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.JPA2_1;	18	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.JPA2_1;
23	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.OrmV2_1Package;	19	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.OrmV2_1Package;
24	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1;	20	import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1;
Lines 64-77 Link Here
64	protected String description = DESCRIPTION_EDEFAULT;	60	protected String description = DESCRIPTION_EDEFAULT;
65		61
66	/**	62	/**
67	* The default value of the '{@link #getMode() <em>Mode</em>}' attribute.	63	* changed this to null and removed the generated flag so emf won't generate over it
68	* <!-- begin-user-doc -->	64	* we don't want a default for enums, just null if the tag does not exist
69	* <!-- end-user-doc -->
70	* @see #getMode()
71	* @generated
72	* @ordered
73	*/	65	*/
74	protected static final ParameterMode_2_1 MODE_EDEFAULT = ParameterMode_2_1.IN;	66	protected static final ParameterMode_2_1 MODE_EDEFAULT = null;
75		67
76	/**	68	/**
77	* The cached value of the '{@link #getMode() <em>Mode</em>}' attribute.	69	* The cached value of the '{@link #getMode() <em>Mode</em>}' attribute.

Lines 1-5 Link Here

(-)src/org/eclipse/jpt/jpa/core/context/QueryContainer.java (-3 / +45 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2012 Oracle. All rights reserved.	2	* Copyright (c) 2008, 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-18 Link Here
10	package org.eclipse.jpt.jpa.core.context;	10	package org.eclipse.jpt.jpa.core.context;
11		11
12	import org.eclipse.jpt.common.utility.iterable.ListIterable;	12	import org.eclipse.jpt.common.utility.iterable.ListIterable;
		13	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1;
13		14
14	/**	15	/**
15	* Container for named queries and/or named native queries.	16	* Container for named queries and/or named native queries and/or named stored procedure queries.
16	* Used by entities and the <code>orm.xml</code>	17	* Used by entities and the <code>orm.xml</code>
17	* </code>entity-mappings</code> element.	18	* </code>entity-mappings</code> element.
18	* <p>	19	* <p>
Lines 22-28 Link Here
22	* pioneering adopters on the understanding that any code that uses this API	23	* pioneering adopters on the understanding that any code that uses this API
23	* will almost certainly be broken (repeatedly) as the API evolves.	24	* will almost certainly be broken (repeatedly) as the API evolves.
24	*	25	*
25	* @version 2.2	26	* @version 3.3
26	* @since 2.2	27	* @since 2.2
27	*/	28	*/
28	public interface QueryContainer	29	public interface QueryContainer
Lines 115-118 Link Here
115	*/	116	*/
116	void moveNamedNativeQuery(int targetIndex, int sourceIndex);	117	void moveNamedNativeQuery(int targetIndex, int sourceIndex);
117		118
		119
		120	// ******** named stored procedure queries ********
		121
		122	/**
		123	* Return the container's named stored procedure queries.
		124	*/
		125	ListIterable<? extends NamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries();
		126
		127	String NAMED_STORED_PROCEDURE_QUERIES_LIST = "namedStoredProcedureQueries"; //$NON-NLS-1$
		128
		129	/**
		130	* Return the number of named stored procedure queries.
		131	*/
		132	int getNamedStoredProcedureQueriesSize();
		133
		134	/**
		135	* Add a new named stored procedure query to the container and return it.
		136	*/
		137	NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery();
		138
		139	/**
		140	* Add a new named stored procedure query to the container at the specified index
		141	* and return it.
		142	*/
		143	NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index);
		144
		145	/**
		146	* Remove from the container the named stored procedure query at the specified index.
		147	*/
		148	void removeNamedStoredProcedureQuery(int index);
		149
		150	/**
		151	* Remove the specified named stored procedure query from the container.
		152	*/
		153	void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery);
		154
		155	/**
		156	* Move a named stored procedure query as specified.
		157	*/
		158	void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex);
		159
118	}	160	}

Lines 7-36 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/GenericJpaFactory2_1.java (-16 / +36 lines)
7	* Contributors:	7	* Contributors:
8	* Oracle - initial API and implementation	8	* Oracle - initial API and implementation
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.jpa.core.internal.jpa2_1;	10	package org.eclipse.jpt.jpa.core.internal.jpa2_1;
11		11
12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;	12	import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;	13	import org.eclipse.jpt.jpa.core.context.JpaContextNode;
		14	import org.eclipse.jpt.jpa.core.context.java.JavaQuery;
14	import org.eclipse.jpt.jpa.core.internal.jpa2.GenericJpaFactory2_0;	15	import org.eclipse.jpt.jpa.core.internal.jpa2.GenericJpaFactory2_0;
15	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType;	16	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType;
		17	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaNamedStoredProcedureQuery2_1;
		18	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaStoredProcedureParameter2_1;
		19	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1;
		20	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1;
		21	import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1;
16	import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;	22	import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;
17	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;	23	import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1;
18		24	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
19		25	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
20	/**	26
21	* Central class that allows extenders to easily replace implementations of	27
22	* various Dali interfaces.	28	/**
23	*/	29	* Central class that allows extenders to easily replace implementations of
24	public class GenericJpaFactory2_1	30	* various Dali interfaces.
25	extends GenericJpaFactory2_0	31	*/
26	implements JpaFactory2_1	32	public class GenericJpaFactory2_1
27	{	33	extends GenericJpaFactory2_0
28		34	implements JpaFactory2_1
29	public GenericJpaFactory2_1() {	35	{
30	super();	36
		37	public GenericJpaFactory2_1() {
		38	super();
		39	}
		40
		41	public JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1(
		42	JavaQuery parent,
		43	StoredProcedureParameter2_1Annotation parameterAnnotation) {
		44	return new GenericJavaStoredProcedureParameter2_1(parent, parameterAnnotation);
		45	}
		46
		47	public JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1(
		48	JavaQueryContainer2_1 parent,
		49	NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) {
		50	return new GenericJavaNamedStoredProcedureQuery2_1(parent, namedStoredProcedureQueryAnnotation);
31	}	51	}
32		52
33	public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) {	53	public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) {
34	return new GenericJavaConverterType(parent, jrt);	54	return new GenericJavaConverterType(parent, jrt);
35	}	55	}
36	}	56	}

Added Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/NamedStoredProcedureQuery2_1.java (+169 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.context;
11
12	import org.eclipse.jpt.common.utility.iterable.ListIterable;
13	import org.eclipse.jpt.jpa.core.context.Query;
14
15	/**
16	* named stored procedure query
17	* <p>
18	* Provisional API: This interface is part of an interim API that is still
19	* under development and expected to change significantly before reaching
20	* stability. It is available at this early stage to solicit feedback from
21	* pioneering adopters on the understanding that any code that uses this API
22	* will almost certainly be broken (repeatedly) as the API evolves.
23	*
24	* @version 3.3
25	* @since 3.3
26	*/
27	public interface NamedStoredProcedureQuery2_1
28	extends Query
29	{
30
31	// ******** procedure name ********
32
33	String getProcedureName();
34	String PROCEDURE_NAME_PROPERTY = "procedureName"; //$NON-NLS-1$
35
36	void setProcedureName(String procedureName);
37
38
39	// ******** parameters ********
40
41	/**
42	* Return the query's parameters.
43	*/
44	ListIterable<? extends StoredProcedureParameter2_1> getParameters();
45	String PARAMETERS_LIST = "parameters"; //$NON-NLS-1$
46
47	/**
48	* Return the number of parameters in the query.
49	*/
50	int getParametersSize();
51
52	/**
53	* Add a parameter to the query and return the object representing it.
54	*/
55	StoredProcedureParameter2_1 addParameter();
56
57	/**
58	* Add a parameter to the index and return the object representing it.
59	*/
60	StoredProcedureParameter2_1 addParameter(int index);
61
62	/**
63	* Remove the parameter from the query.
64	*/
65	void removeParameter(StoredProcedureParameter2_1 parameter);
66
67	/**
68	* Remove the parameter at the index from the query.
69	*/
70	void removeParameter(int index);
71
72	/**
73	* Move the hint from the source index to the target index.
74	*/
75	void moveParameter(int targetIndex, int sourceIndex);
76
77	/**
78	* Return the parameter at the index.
79	*/
80	StoredProcedureParameter2_1 getParameter(int index);
81
82	// ******** result classes ********
83
84	/**
85	* Return the query's result classes.
86	*/
87	ListIterable<String> getResultClasses();
88	String RESULT_CLASSES_LIST = "resultClasses"; //$NON-NLS-1$
89
90	/**
91	* Return the number of result classes in the query.
92	*/
93	int getResultClassesSize();
94
95	/**
96	* Return the result class at the index.
97	*/
98	String getResultClass(int index);
99
100	/**
101	* Add the result class to the query.
102	*/
103	void addResultClass(String resultClass);
104
105	/**
106	* Add the result class to the index.
107	*/
108	void addResultClass(int index, String resultClass);
109
110	/**
111	* Remove the result class from the query's list of result classes.
112	*/
113	void removeResultClass(String resultClass);
114
115	/**
116	* Remove the result class at the index.
117	*/
118	void removeResultClass(int index);
119
120	/**
121	* Move the result class from the source index to the target index.
122	*/
123	void moveResultClass(int targetIndex, int sourceIndex);
124
125
126	// ******** result set mappings ********
127
128	/**
129	* Return the query's result set mappings.
130	*/
131	ListIterable<String> getResultSetMappings();
132	String RESULT_SET_MAPPINGS_LIST = "resultSetMappings"; //$NON-NLS-1$
133
134	/**
135	* Return the number of result set mappings in the query.
136	*/
137	int getResultSetMappingsSize();
138
139	/**
140	* Return the result class at the index.
141	*/
142	String getResultSetMapping(int index);
143
144
145	/**
146	* Add the result set mapping to the query.
147	*/
148	void addResultSetMapping(String resultClass);
149
150	/**
151	* Add the result set mapping to the index.
152	*/
153	void addResultSetMapping(int index, String resultClass);
154
155	/**
156	* Remove the result set mapping from the query's list of result set mappings.
157	*/
158	void removeResultSetMapping(String resultClass);
159
160	/**
161	* Remove the result set mapping at the index.
162	*/
163	void removeResultSetMapping(int index);
164
165	/**
166	* Move the result set mapping from the source index to the target index.
167	*/
168	void moveResultSetMapping(int targetIndex, int sourceIndex);
169	}

Lines 26-32 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/source/SourceStoredProcedureParameter2_1Annotation.java (-11 / +11 lines)
26	import org.eclipse.jpt.common.core.utility.jdt.ExpressionConverter;	26	import org.eclipse.jpt.common.core.utility.jdt.ExpressionConverter;
27	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;	27	import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter;
28	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;	28	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
29	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1;	29	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1;
30	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;	30	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
31		31
32	/**	32	/**
Lines 43-49 Link Here
43		43
44	private DeclarationAnnotationElementAdapter<String> modeDeclarationAdapter;	44	private DeclarationAnnotationElementAdapter<String> modeDeclarationAdapter;
45	private AnnotationElementAdapter<String> modeAdapter;	45	private AnnotationElementAdapter<String> modeAdapter;
46	private ParameterMode2_1 mode;	46	private ParameterMode_2_1 mode;
47	private TextRange modeTextRange;	47	private TextRange modeTextRange;
48		48
49	private DeclarationAnnotationElementAdapter<String> typeDeclarationAdapter;	49	private DeclarationAnnotationElementAdapter<String> typeDeclarationAdapter;
Lines 166-190 Link Here
166	}	166	}
167		167
168	// ***** mode	168	// ***** mode
169	public ParameterMode2_1 getMode() {	169	public ParameterMode_2_1 getMode() {
170	return this.mode;	170	return this.mode;
171	}	171	}
172		172
173	public void setMode(ParameterMode2_1 mode) {	173	public void setMode(ParameterMode_2_1 mode) {
174	if (this.attributeValueHasChanged(this.mode, mode)) {	174	if (this.attributeValueHasChanged(this.mode, mode)) {
175	this.mode = mode;	175	this.mode = mode;
176	this.modeAdapter.setValue(ParameterMode2_1.toJavaAnnotationValue(mode));	176	this.modeAdapter.setValue(ParameterMode_2_1.toJavaAnnotationValue(mode));
177	}	177	}
178	}	178	}
179		179
180	private void syncMode(ParameterMode2_1 astValue) {	180	private void syncMode(ParameterMode_2_1 astValue) {
181	ParameterMode2_1 old = this.mode;	181	ParameterMode_2_1 old = this.mode;
182	this.mode = astValue;	182	this.mode = astValue;
183	this.firePropertyChanged(MODE_PROPERTY, old, astValue);	183	this.firePropertyChanged(MODE_PROPERTY, old, astValue);
184	}	184	}
185		185
186	private ParameterMode2_1 buildMode(Annotation astAnnotation) {	186	private ParameterMode_2_1 buildMode(Annotation astAnnotation) {
187	return ParameterMode2_1.fromJavaAnnotationValue(this.modeAdapter.getValue(astAnnotation));	187	return ParameterMode_2_1.fromJavaAnnotationValue(this.modeAdapter.getValue(astAnnotation));
188	}	188	}
189		189
190	public TextRange getModeTextRange() {	190	public TextRange getModeTextRange() {
Lines 204-214 Link Here
204	}	204	}
205		205
206	// ***** type	206	// ***** type
207	public String getType() {	207	public String getTypeName() {
208	return this.type;	208	return this.type;
209	}	209	}
210		210
211	public void setType(String type) {	211	public void setTypeName(String type) {
212	if (this.attributeValueHasChanged(this.type, type)) {	212	if (this.attributeValueHasChanged(this.type, type)) {
213	this.type = type;	213	this.type = type;
214	this.fqTypeNameStale = true;	214	this.fqTypeNameStale = true;

Added Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/ParameterMode2_1.java (+106 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.jpa2_1;
11
12
13	/**
14	* parameter mode
15	*
16	* Provisional API: This interface is part of an interim API that is still
17	* under development and expected to change significantly before reaching
18	* stability. It is available at this early stage to solicit feedback from
19	* pioneering adopters on the understanding that any code that uses this API
20	* will almost certainly be broken (repeatedly) as the API evolves.
21	*
22	* @version 3.3
23	* @since 3.3
24	*/
25	public enum ParameterMode2_1
26	{
27	IN(
28	org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.IN,
29	org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.IN
30	),
31	INOUT(
32	org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.INOUT,
33	org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.INOUT
34	),
35	OUT(
36	org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.OUT,
37	org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.OUT
38	),
39	REF_CURSOR(
40	org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.REF_CURSOR,
41	org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.REF_CURSOR
42	);
43
44
45	private org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode;
46	private org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode;
47
48	ParameterMode2_1(
49	org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode,
50	org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
51	if (javaParameterMode == null) {
52	throw new NullPointerException();
53	}
54	if (ormParameterMode == null) {
55	throw new NullPointerException();
56	}
57	this.javaParameterMode = javaParameterMode;
58	this.ormParameterMode = ormParameterMode;
59	}
60
61	public org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 getJavaParameterMode() {
62	return this.javaParameterMode;
63	}
64
65	public org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 getOrmParameterMode() {
66	return this.ormParameterMode;
67	}
68
69
70	// ******** static methods ********
71
72	public static ParameterMode2_1 fromJavaResourceModel(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) {
73	return (javaParameterMode == null) ? null : fromJavaResourceModel_(javaParameterMode);
74	}
75
76	private static ParameterMode2_1 fromJavaResourceModel_(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) {
77	for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) {
78	if (parameterMode.getJavaParameterMode() == javaParameterMode) {
79	return parameterMode;
80	}
81	}
82	return null;
83	}
84
85	public static org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 toJavaResourceModel(ParameterMode2_1 parameterMode) {
86	return (parameterMode == null) ? null : parameterMode.getJavaParameterMode();
87	}
88
89
90	public static ParameterMode2_1 fromOrmResourceModel(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
91	return (ormParameterMode == null) ? null : fromOrmResourceModel_(ormParameterMode);
92	}
93
94	private static ParameterMode2_1 fromOrmResourceModel_(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) {
95	for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) {
96	if (parameterMode.getOrmParameterMode() == ormParameterMode) {
97	return parameterMode;
98	}
99	}
100	return null;
101	}
102
103	public static org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 toOrmResourceModel(ParameterMode2_1 parameterMode) {
104	return (parameterMode == null) ? null : parameterMode.getOrmParameterMode();
105	}
106	}

Lines 56-69 Link Here

(-)src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/StoredProcedureParameter2_1Annotation.java (-4 / +4 lines)
56	* Corresponds to the 'mode' element of the StoredProcedureParameter annotation.	56	* Corresponds to the 'mode' element of the StoredProcedureParameter annotation.
57	* Return null if the element does not exist in the annotation	57	* Return null if the element does not exist in the annotation
58	*/	58	*/
59	ParameterMode2_1 getMode();	59	ParameterMode_2_1 getMode();
60	String MODE_PROPERTY = "mode"; //$NON-NLS-1$	60	String MODE_PROPERTY = "mode"; //$NON-NLS-1$
61		61
62	/**	62	/**
63	* Corresponds to the 'mode' element of the StoredProcedureParameter annotation.	63	* Corresponds to the 'mode' element of the StoredProcedureParameter annotation.
64	* Setting to null will remove the element.	64	* Setting to null will remove the element.
65	*/	65	*/
66	void setMode(ParameterMode2_1 mode);	66	void setMode(ParameterMode_2_1 mode);
67		67
68	/**	68	/**
69	* Return the {@link TextRange} for the 'mode' element. If the element	69	* Return the {@link TextRange} for the 'mode' element. If the element
Lines 77-90 Link Here
77	* Corresponds to the 'type' element of the StoredProcedureParameter annotation.	77	* Corresponds to the 'type' element of the StoredProcedureParameter annotation.
78	* Return null if the element does not exist in the annotation	78	* Return null if the element does not exist in the annotation
79	*/	79	*/
80	String getType();	80	String getTypeName();
81	String TYPE_PROPERTY = "type"; //$NON-NLS-1$	81	String TYPE_PROPERTY = "type"; //$NON-NLS-1$
82		82
83	/**	83	/**
84	* Corresponds to the 'type' element of the StoredProcedureParameter annotation.	84	* Corresponds to the 'type' element of the StoredProcedureParameter annotation.
85	* Setting to null will remove the element.	85	* Setting to null will remove the element.
86	*/	86	*/
87	void setType(String type);	87	void setTypeName(String type);
88		88
89	/**	89	/**
90	* Return the {@link TextRange} for the 'type' element. If the element	90	* Return the {@link TextRange} for the 'type' element. If the element

Lines 15-21 Link Here

(-)src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/StoredProcedureParameter2_1AnnotationTests.java (-13 / +13 lines)
15	import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;	15	import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
16	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;	16	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1;
17	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;	17	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation;
18	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1;	18	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1;
19	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;	19	import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation;
20		20
21	@SuppressWarnings("nls")	21	@SuppressWarnings("nls")
Lines 85-91 Link Here
85		85
86	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);	86	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
87	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);	87	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
88	assertEquals(ParameterMode2_1.IN, parameter.getMode());	88	assertEquals(ParameterMode_2_1.IN, parameter.getMode());
89	}	89	}
90		90
91	public void testSetMode() throws Exception {	91	public void testSetMode() throws Exception {
Lines 94-103 Link Here
94		94
95	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);	95	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
96	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);	96	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
97	assertEquals(ParameterMode2_1.IN, parameter.getMode());	97	assertEquals(ParameterMode_2_1.IN, parameter.getMode());
98		98
99	parameter.setMode(ParameterMode2_1.INOUT);	99	parameter.setMode(ParameterMode_2_1.INOUT);
100	assertEquals(ParameterMode2_1.INOUT, parameter.getMode());	100	assertEquals(ParameterMode_2_1.INOUT, parameter.getMode());
101	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = INOUT, type = MyType.class)", cu);	101	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = INOUT, type = MyType.class)", cu);
102		102
103	parameter.setMode(null);	103	parameter.setMode(null);
Lines 114-120 Link Here
114	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);	114	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
115	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);	115	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
116		116
117	assertEquals("MyType", parameter.getType());	117	assertEquals("MyType", parameter.getTypeName());
118	}	118	}
119		119
120	public void testSetType() throws Exception {	120	public void testSetType() throws Exception {
Lines 124-137 Link Here
124	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);	124	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
125	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);	125	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
126		126
127	assertEquals("MyType", parameter.getType());	127	assertEquals("MyType", parameter.getTypeName());
128		128
129	parameter.setType("Foo");	129	parameter.setTypeName("Foo");
130	assertEquals("Foo", parameter.getType());	130	assertEquals("Foo", parameter.getTypeName());
131	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = Foo.class", cu);	131	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = Foo.class", cu);
132		132
133	parameter.setType(null);	133	parameter.setTypeName(null);
134	assertNull(parameter.getType());	134	assertNull(parameter.getTypeName());
135	assertSourceDoesNotContain("type", cu);	135	assertSourceDoesNotContain("type", cu);
136	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN", cu);	136	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN", cu);
137	}	137	}
Lines 143-152 Link Here
143	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);	143	NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY);
144	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);	144	StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0);
145		145
146	assertNotNull(parameter.getType());	146	assertNotNull(parameter.getTypeName());
147	assertEquals("MyType", parameter.getFullyQualifiedTypeName());	147	assertEquals("MyType", parameter.getFullyQualifiedTypeName());
148		148
149	parameter.setType(TYPE_NAME);	149	parameter.setTypeName(TYPE_NAME);
150		150
151	assertEquals(FULLY_QUALIFIED_TYPE_NAME, parameter.getFullyQualifiedTypeName());	151	assertEquals(FULLY_QUALIFIED_TYPE_NAME, parameter.getFullyQualifiedTypeName());
152	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = " + TYPE_NAME + ".class)", cu);	152	assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = " + TYPE_NAME + ".class)", cu);