Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate, Relational Persistence for Idiomatic Java
   *
   * Copyright (c) 2010, Red Hat Inc. or third-party contributors as
   * indicated by the @author tags or express copyright attribution
   * statements applied by the authors.  All third-party contributions are
   * distributed under license by Red Hat Inc.
   *
   * This copyrighted material is made available to anyone wishing to use, modify,
  * copy, or redistribute it subject to the terms and conditions of the GNU
  * Lesser General Public License, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  * for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this distribution; if not, write to:
  * Free Software Foundation, Inc.
  * 51 Franklin Street, Fifth Floor
  * Boston, MA  02110-1301  USA
  */
 package org.hibernate.ejb.criteria.path;
 
 import java.util.Set;
 
Convenience base class for various javax.persistence.criteria.From implementors.

Author(s):
Steve Ebersole
 
 public abstract class AbstractFromImpl<Z,X>
 		extends AbstractPathImpl<X>
 		implements From<Z,X>, FromImplementor<Z,X>, Serializable {
 
 	public static final JoinType DEFAULT_JOIN_TYPE = .;
 
     private Set<Join<X, ?>> joins;
     private Set<Fetch<X, ?>> fetches;
 
 	public AbstractFromImpl(CriteriaBuilderImpl criteriaBuilderClass<X> javaType) {
 		thiscriteriaBuilderjavaTypenull );
 	}
 
 	public AbstractFromImpl(CriteriaBuilderImpl criteriaBuilderClass<X> javaTypePathSource pathSource) {
 		supercriteriaBuilderjavaTypepathSource );
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public PathSource<Z> getPathSource() {
 		return super.getPathSource();
 	}
 
 	public String getPathIdentifier() {
 		return getAlias();
 	}
 
 	protected boolean canBeDereferenced() {
 		return true;
 	}
 
 	public void prepareAlias(CriteriaQueryCompiler.RenderingContext renderingContext) {
		if ( getAlias() == null ) {
			if ( isCorrelated() ) {
			}
			else {
				setAliasrenderingContext.generateAlias() );
			}
		}
	}
		prepareAliasrenderingContext );
		return getAlias();
	}
	public String render(CriteriaQueryCompiler.RenderingContext renderingContext) {
		return renderProjectionrenderingContext );
	}
	public Attribute<?, ?> getAttribute() {
		return null;
	}
	public From<?, Z> getParent() {
		return null;
	}
	@SuppressWarnings({ "unchecked" })
	protected Attribute<X, ?> locateAttributeInternal(String name) {
		return (Attribute<X, ?>) locateManagedType().getAttributename );
	}
	@SuppressWarnings({ "unchecked" })
	protected ManagedType<? super X> locateManagedType() {
		// by default, this should be the model
		return (ManagedType<? super X>) getModel();
	}
	// CORRELATION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// IMPL NOTE : another means from handling correlations is to create a series of
	//		specialized From implementations that represent the correlation roots.  While
	//		that may be cleaner code-wise, it is certainly means creating a lot of "extra"
	//		classes since we'd need one for each Subquery#correlate method
	private JoinScope<X> joinScope = new BasicJoinScope();

Helper contract used to define who/what keeps track of joins and fetches made from this FROM.
	public static interface JoinScope<X> extends Serializable {
		public void addJoin(Join<X, ?> join);
		public void addFetch(Fetch<X,?> fetch);
	}
	protected class BasicJoinScope implements JoinScope<X> {
		public void addJoin(Join<X, ?> join) {
			if (  == null ) {
				 = new LinkedHashSet<Join<X,?>>();
			}
			.addjoin );
		}
		public void addFetch(Fetch<X, ?> fetch) {
			if (  == null ) {
				 = new LinkedHashSet<Fetch<X,?>>();
			}
			.addfetch );
		}
	}
	protected class CorrelationJoinScope implements JoinScope<X> {
		public void addJoin(Join<X, ?> join) {
			if (  == null ) {
				 = new LinkedHashSet<Join<X,?>>();
			}
			.addjoin );
		}
		public void addFetch(Fetch<X, ?> fetch) {
			throw new UnsupportedOperationException"Cannot define fetch from a subquery correlation" );
		}
	}
	public boolean isCorrelated() {
		return getCorrelationParent() != null;
	}
	}
	@SuppressWarnings({ "unchecked" })
	public FromImplementor<Z, X> correlateTo(CriteriaSubqueryImpl subquery) {
		final FromImplementor<Z, X> correlationDelegate = createCorrelationDelegate();
		correlationDelegate.prepareCorrelationDelegatethis );
		return correlationDelegate;
	}
	protected abstract FromImplementor<Z, X> createCorrelationDelegate();
	public void prepareCorrelationDelegate(FromImplementor<Z, X> parent) {
		this. = parent;
	}
	public String getAlias() {
		return isCorrelated() ? getCorrelationParent().getAlias() : super.getAlias();
	}
	// JOINS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	protected abstract boolean canBeJoinSource();
				"Collection of values [" + getPathIdentifier() + "] cannot be source of a join"
		);
	}
	@SuppressWarnings({ "unchecked" })
	public Set<Join<X, ?>> getJoins() {
		return  == null
	}
	public <Y> Join<X, Y> join(SingularAttribute<? super X, Y> singularAttribute) {
		return joinsingularAttribute );
	}
	public <Y> Join<X, Y> join(SingularAttribute<? super X, Y> attributeJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		Join<X, Y> join = constructJoinattributejt );
		.addJoinjoin );
		return join;
	}
	private <Y> JoinImplementor<X, Y> constructJoin(SingularAttribute<? super X, Y> attributeJoinType jt) {
			throw new BasicPathUsageException"Cannot join to attribute of basic type"attribute );
        }
		// TODO : runtime check that the attribute in fact belongs to this From's model/bindable
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		final Class<Y> attributeType = attribute.getBindableJavaType();
		return new SingularAttributeJoin<X,Y>(
				attributeType,
				this,
				attribute,
				jt
		);
	}
	public <Y> CollectionJoin<X, Y> join(CollectionAttribute<? super X, Y> collection) {
		return joincollection );
	}
	public <Y> CollectionJoin<X, Y> join(CollectionAttribute<? super X, Y> collectionJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		final CollectionJoin<X, Y> join = constructJoincollectionjt );
		.addJoinjoin );
		return join;
	}
	private <Y> CollectionJoinImplementor<X, Y> constructJoin(CollectionAttribute<? super X, Y> collectionJoinType jt) {
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		// TODO : runtime check that the attribute in fact belongs to this From's model/bindable
		final Class<Y> attributeType = collection.getBindableJavaType();
		return new CollectionAttributeJoin<X, Y>(
				attributeType,
				this,
				collection,
				jt
		);
	}
	public <Y> SetJoin<X, Y> join(SetAttribute<? super X, Y> set) {
		return joinset );
	}
	public <Y> SetJoin<X, Y> join(SetAttribute<? super X, Y> setJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		final SetJoin<X, Y> join = constructJoinsetjt );
		.addJoinjoin );
		return join;
	}
	private <Y> SetJoinImplementor<X, Y> constructJoin(SetAttribute<? super X, Y> setJoinType jt) {
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		// TODO : runtime check that the attribute in fact belongs to this From's model/bindable
		final Class<Y> attributeType = set.getBindableJavaType();
		return new SetAttributeJoin<X,Y>( criteriaBuilder(), attributeTypethissetjt );
	}
	public <Y> ListJoin<X, Y> join(ListAttribute<? super X, Y> list) {
		return joinlist );
	}
	public <Y> ListJoin<X, Y> join(ListAttribute<? super X, Y> listJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		final ListJoin<X, Y> join = constructJoinlistjt );
		.addJoinjoin );
		return join;
	}
	private  <Y> ListJoinImplementor<X, Y> constructJoin(ListAttribute<? super X, Y> listJoinType jt) {
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		// TODO : runtime check that the attribute in fact belongs to this From's model/bindable
		final Class<Y> attributeType = list.getBindableJavaType();
		return new ListAttributeJoin<X,Y>( criteriaBuilder(), attributeTypethislistjt );
	}
	public <K, V> MapJoin<X, K, V> join(MapAttribute<? super X, K, V> map) {
		return joinmap );
	}
	public <K, V> MapJoin<X, K, V> join(MapAttribute<? super X, K, V> mapJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		final MapJoin<X, K, V> join = constructJoinmapjt );
		.addJoinjoin );
		return join;
	}
	private <K, V> MapJoinImplementor<X, K, V> constructJoin(MapAttribute<? super X, K, V> mapJoinType jt) {
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		// TODO : runtime check that the attribute in fact belongs to this From's model/bindable
		final Class<V> attributeType = map.getBindableJavaType();
		return new MapAttributeJoin<X, K, V>( criteriaBuilder(), attributeTypethismapjt );
	}
	public <X,Y> Join<X, Y> join(String attributeName) {
		return joinattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X,Y> Join<X, Y> join(String attributeNameJoinType jt) {
		if ( ! canBeJoinSource() ) {
			throw illegalJoin();
		}
		if ( jt.equals. ) ) {
			throw new UnsupportedOperationException"RIGHT JOIN not supported" );
		}
		final Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( attribute.isCollection() ) {
			final PluralAttribute pluralAttribute = ( PluralAttribute ) attribute;
				return (Join<X,Y>) join( (CollectionAttributeattributejt );
			}
			else if ( ...equalspluralAttribute.getCollectionType() ) ) {
				return (Join<X,Y>) join( (ListAttributeattributejt );
			}
			else if ( ...equalspluralAttribute.getCollectionType() ) ) {
				return (Join<X,Y>) join( (SetAttributeattributejt );
			}
			else {
				return (Join<X,Y>) join( (MapAttributeattributejt );
			}
		}
		else {
			return (Join<X,Y>) join( (SingularAttribute)attributejt );
		}
	}
	public <X,Y> CollectionJoin<X, Y> joinCollection(String attributeName) {
		return joinCollectionattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X,Y> CollectionJoin<X, Y> joinCollection(String attributeNameJoinType jt) {
		final Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( ! attribute.isCollection() ) {
            throw new IllegalArgumentException"Requested attribute was not a collection" );
		}
		final PluralAttribute pluralAttribute = ( PluralAttribute ) attribute;
		if ( ! ...equalspluralAttribute.getCollectionType() ) ) {
            throw new IllegalArgumentException"Requested attribute was not a collection" );
		}
		return (CollectionJoin<X,Y>) join( (CollectionAttributeattributejt );
	}
	public <X,Y> SetJoin<X, Y> joinSet(String attributeName) {
		return joinSetattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X,Y> SetJoin<X, Y> joinSet(String attributeNameJoinType jt) {
		final Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( ! attribute.isCollection() ) {
            throw new IllegalArgumentException"Requested attribute was not a set" );
		}
		final PluralAttribute pluralAttribute = ( PluralAttribute ) attribute;
		if ( ! ...equalspluralAttribute.getCollectionType() ) ) {
            throw new IllegalArgumentException"Requested attribute was not a set" );
		}
		return (SetJoin<X,Y>) join( (SetAttributeattributejt );
	}
	public <X,Y> ListJoin<X, Y> joinList(String attributeName) {
		return joinListattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X,Y> ListJoin<X, Y> joinList(String attributeNameJoinType jt) {
		final Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( ! attribute.isCollection() ) {
            throw new IllegalArgumentException"Requested attribute was not a list" );
		}
		final PluralAttribute pluralAttribute = ( PluralAttribute ) attribute;
		if ( ! ...equalspluralAttribute.getCollectionType() ) ) {
            throw new IllegalArgumentException"Requested attribute was not a list" );
		}
		return (ListJoin<X,Y>) join( (ListAttributeattributejt );
	}
	public <X, K, V> MapJoin<X, K, V> joinMap(String attributeName) {
		return joinMapattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X, K, V> MapJoin<X, K, V> joinMap(String attributeNameJoinType jt) {
		final Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( ! attribute.isCollection() ) {
            throw new IllegalArgumentException"Requested attribute was not a map" );
		}
		final PluralAttribute pluralAttribute = ( PluralAttribute ) attribute;
		if ( ! ...equalspluralAttribute.getCollectionType() ) ) {
            throw new IllegalArgumentException"Requested attribute was not a map" );
		}
		return (MapJoin<X,K,V>) join( (MapAttributeattributejt );
	}
	// FETCHES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	protected boolean canBeFetchSource() {
		// the conditions should be the same...
		return canBeJoinSource();
	}
				"Collection of values [" + getPathIdentifier() + "] cannot be source of a fetch"
		);
	}
	@SuppressWarnings({ "unchecked" })
	public Set<Fetch<X, ?>> getFetches() {
		return  == null
	}
	public <Y> Fetch<X, Y> fetch(SingularAttribute<? super X, Y> singularAttribute) {
		return fetchsingularAttribute );
	}
	public <Y> Fetch<X, Y> fetch(SingularAttribute<? super X, Y> attributeJoinType jt) {
		if ( ! canBeFetchSource() ) {
			throw illegalFetch();
		}
		Fetch<X, Y> fetch = constructJoinattributejt );
		.addFetchfetch );
		return fetch;
	}
	public <Y> Fetch<X, Y> fetch(PluralAttribute<? super X, ?, Y> pluralAttribute) {
		return fetchpluralAttribute );
	}
	public <Y> Fetch<X, Y> fetch(PluralAttribute<? super X, ?, Y> pluralAttributeJoinType jt) {
		if ( ! canBeFetchSource() ) {
			throw illegalFetch();
		}
		final Fetch<X, Y> fetch;
		// TODO : combine Fetch and Join hierarchies (JoinImplementor extends Join,Fetch???)
			fetch = constructJoin( (CollectionAttribute<X,Y>) pluralAttributejt );
		}
		else if ( ...equalspluralAttribute.getCollectionType() ) ) {
			fetch = constructJoin( (ListAttribute<X,Y>) pluralAttributejt );
		}
		else if ( ...equalspluralAttribute.getCollectionType() ) ) {
			fetch = constructJoin( (SetAttribute<X,Y>) pluralAttributejt );
		}
		else {
			fetch = constructJoin( (MapAttribute<X,?,Y>) pluralAttributejt );
		}
		.addFetchfetch );
		return fetch;
	}
	public <X,Y> Fetch<X, Y> fetch(String attributeName) {
		return fetchattributeName );
	}
	@SuppressWarnings({ "unchecked" })
	public <X,Y> Fetch<X, Y> fetch(String attributeNameJoinType jt) {
		if ( ! canBeFetchSource() ) {
			throw illegalFetch();
		}
		Attribute<X,?> attribute = (Attribute<X, ?>) locateAttributeattributeName );
		if ( attribute.isCollection() ) {
			return (Fetch<X, Y>) fetch( (PluralAttributeattributejt );
		}
		else {
			return (Fetch<X, Y>) fetch( (SingularAttributeattributejt );
		}
	}
New to GrepCode? Check out our FAQ X