Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2009, Red Hat Middleware LLC 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 Middleware LLC.
   *
   * 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.metamodel;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
Defines a context for storing information during the building of the MetamodelImpl.

This contextual information includes data needing to be processed in a second pass as well as cross-references into the built metamodel classes.

At the end of the day, clients are interested in the getEntityTypeMap() and getEmbeddableTypeMap() results, which represent all the registered entities and embeddables respectively.

Author(s):
Steve Ebersole
Emmanuel Bernard
 
 class MetadataContext {
 
     private static final EntityManagerMessageLogger LOG = Logger.getMessageLogger(EntityManagerMessageLogger.class,
                                                                            MetadataContext.class.getName());
 
     private final boolean ignoreUnsupported;
 	private final AttributeFactory attributeFactory = new AttributeFactorythis );
 
 			= new HashMap<Class<?>, EntityTypeImpl<?>>();
 			= new HashMap<StringEntityTypeImpl<?>>();
 			= new HashMap<Class<?>, EmbeddableTypeImpl<?>>();
 	//this list contains MappedSuperclass and EntityTypes ordered by superclass first
 	private List<ObjectorderedMappings = new ArrayList<Object>();
Stack of PersistentClass being process. Last in the list is the highest in the stack.
 
 
 	public MetadataContext(SessionFactoryImplementor sessionFactoryboolean ignoreUnsupported) {
 		this. = sessionFactory;
         this. = ignoreUnsupported;
 	}
 
 		return ;
	}
    /*package*/ boolean isIgnoreUnsupported() {
        return ;
    }

    
Retrieves the java type to EntityTypeImpl map.

Returns:
The java type to EntityTypeImpl map.
		return Collections.unmodifiableMap );
	}
		return Collections.unmodifiableMap );
	}
		// we need to actually build this map...
		final Map<Class<?>,MappedSuperclassType<?>> mappedSuperClassTypeMap = CollectionHelper.mapOfSize(
		);
			mappedSuperClassTypeMap.put(
					mappedSuperclassType.getJavaType(),
					mappedSuperclassType
			);
		}
		return mappedSuperClassTypeMap;
	}
	/*package*/ void registerEntityType(PersistentClass persistentClassEntityTypeImpl<?> entityType) {
		.putentityType.getBindableJavaType(), entityType );
		.putpersistentClass.getEntityName(), entityType );
		.putpersistentClassentityType );
		.addpersistentClass );
	}
	/*package*/ void registerEmbeddedableType(EmbeddableTypeImpl<?> embeddableType) {
		.putembeddableType.getJavaType(), embeddableType );
	}
	/*package*/ void registerMappedSuperclassType(MappedSuperclass mappedSuperclass,
												  MappedSuperclassTypeImpl<?> mappedSuperclassType) {
		.putmappedSuperclassmappedSuperclassType );
		.addmappedSuperclass );
	}

Given a Hibernate org.hibernate.mapping.PersistentClass, locate the corresponding JPA org.hibernate.type.EntityType implementation. May retur null if the given org.hibernate.mapping.PersistentClass has not yet been processed.

Parameters:
persistentClass The Hibernate (config time) metamodel instance representing an entity.
Returns:
Tne corresponding JPA org.hibernate.type.EntityType, or null if not yet processed.
	public EntityTypeImpl<?> locateEntityType(PersistentClass persistentClass) {
		return .getpersistentClass );
	}

Given a Java java.lang.Class, locate the corresponding JPA org.hibernate.type.EntityType. May return null which could means that no such mapping exists at least at this time.

Parameters:
javaType The java class.
Returns:
The corresponding JPA org.hibernate.type.EntityType, or null.
	public EntityTypeImpl<?> locateEntityType(Class<?> javaType) {
		return .getjavaType );
	}

Given an entity-name, locate the corresponding JPA org.hibernate.type.EntityType. May return null which could means that no such mapping exists at least at this time.

Parameters:
entityName The entity-name.
Returns:
The corresponding JPA org.hibernate.type.EntityType, or null.
	public EntityTypeImpl<?> locateEntityType(String entityName) {
		return .getentityName );
	}
	@SuppressWarnings({ "unchecked" })
	public void wrapUp() {
        .trace("Wrapping up metadata context...");
		//we need to process types from superclasses to subclasses
		for (Object mapping : ) {
			if ( PersistentClass.class.isAssignableFrommapping.getClass() ) ) {
				@SuppressWarnings"unchecked" )
				final PersistentClass safeMapping = (PersistentClassmapping;
                .trace("Starting entity [" + safeMapping.getEntityName() + "]");
				try {
					final EntityTypeImpl<?> jpa2Mapping = .getsafeMapping );
					applyIdMetadatasafeMappingjpa2Mapping );
					applyVersionAttributesafeMappingjpa2Mapping );
					Iterator<Propertyproperties = safeMapping.getDeclaredPropertyIterator();
					while ( properties.hasNext() ) {
						final Property property = properties.next();
						if ( property.getValue() == safeMapping.getIdentifierMapper() ) {
							// property represents special handling for id-class mappings but we have already
							// accounted for the embedded property mappings in #applyIdMetadata &&
							// #buildIdClassAttributes
							continue;
						}
						if ( safeMapping.isVersioned() && property == safeMapping.getVersion() ) {
							// skip the version property, it was already handled previously.
							continue;
						}
						final Attribute attribute = .buildAttributejpa2Mappingproperty );
						if ( attribute != null ) {
							jpa2Mapping.getBuilder().addAttributeattribute );
						}
					}
					jpa2Mapping.lock();
					populateStaticMetamodeljpa2Mapping );
				}
				finally {
                    .trace("Completed entity [" + safeMapping.getEntityName() + "]");
				}
			}
			else if ( MappedSuperclass.class.isAssignableFrommapping.getClass() ) ) {
				@SuppressWarnings"unchecked" )
				final MappedSuperclass safeMapping = (MappedSuperclassmapping;
                .trace("Starting mapped superclass [" + safeMapping.getMappedClass().getName() + "]");
				try {
							safeMapping
					);
					applyIdMetadatasafeMappingjpa2Mapping );
					applyVersionAttributesafeMappingjpa2Mapping );
					Iterator<Propertyproperties = safeMapping.getDeclaredPropertyIterator();
					while ( properties.hasNext() ) {
						final Property property = properties.next();
						if ( safeMapping.isVersioned() && property == safeMapping.getVersion() ) {
							// skip the version property, it was already handled previously.
							continue;
						}
						final Attribute attribute = .buildAttributejpa2Mappingproperty );
						if ( attribute != null ) {
							jpa2Mapping.getBuilder().addAttributeattribute );
						}
					}
					jpa2Mapping.lock();
					populateStaticMetamodeljpa2Mapping );
				}
				finally {
                    .trace("Completed mapped superclass [" + safeMapping.getMappedClass().getName() + "]");
				}
			}
			else {
				throw new AssertionFailure"Unexpected mapping type: " + mapping.getClass() );
			}
		}
		for ( EmbeddableTypeImpl embeddable : .values() ) {
			populateStaticMetamodelembeddable );
		}
	}
	private <X> void applyIdMetadata(PersistentClass persistentClassEntityTypeImpl<X> jpaEntityType) {
		if ( persistentClass.hasIdentifierProperty() ) {
			final Property declaredIdentifierProperty = persistentClass.getDeclaredIdentifierProperty();
			if (declaredIdentifierProperty != null) {
						.buildIdAttributejpaEntityTypedeclaredIdentifierProperty )
				);
			}
		}
		else if ( persistentClass.hasIdentifierMapper() ) {
			@SuppressWarnings"unchecked")
			Iterator<PropertypropertyIterator = persistentClass.getIdentifierMapper().getPropertyIterator();
			Set<SingularAttribute<? super X, ?>> attributes = buildIdClassAttributesjpaEntityTypepropertyIterator );
			jpaEntityType.getBuilder().applyIdClassAttributesattributes );
		}
		else {
			final KeyValue value = persistentClass.getIdentifier();
			if (value instanceof Component ) {
				final Component component = ( Component ) value;
				if ( component.getPropertySpan() > 1 ) {
					//FIXME we are an Hibernate embedded id (ie not type)
				}
				else {
					//FIXME take care of declared vs non declared property
								jpaEntityType,
								(Propertycomponent.getPropertyIterator().next() )
					);
				}
			}
		}
	}
	private <X> void applyIdMetadata(MappedSuperclass mappingTypeMappedSuperclassTypeImpl<X> jpaMappingType) {
		if ( mappingType.hasIdentifierProperty() ) {
			final Property declaredIdentifierProperty = mappingType.getDeclaredIdentifierProperty();
			if (declaredIdentifierProperty != null) {
				jpaMappingType.getBuilder().applyIdAttribute(
						.buildIdAttributejpaMappingTypedeclaredIdentifierProperty )
				);
			}
		}
		//an MappedSuperclass can have no identifier if the id is set below in the hierarchy
		else if ( mappingType.getIdentifierMapper() != null ){
			@SuppressWarnings"unchecked")
			Iterator<PropertypropertyIterator = mappingType.getIdentifierMapper().getPropertyIterator();
			Set<SingularAttribute<? super X, ?>> attributes = buildIdClassAttributesjpaMappingTypepropertyIterator );
			jpaMappingType.getBuilder().applyIdClassAttributesattributes );
		}
	}
	private <X> void applyVersionAttribute(PersistentClass persistentClassEntityTypeImpl<X> jpaEntityType) {
		final Property declaredVersion = persistentClass.getDeclaredVersion();
		if (declaredVersion != null) {
					.buildVersionAttributejpaEntityTypedeclaredVersion )
			);
		}
	}
	private <X> void applyVersionAttribute(MappedSuperclass mappingTypeMappedSuperclassTypeImpl<X> jpaMappingType) {
		final Property declaredVersion = mappingType.getDeclaredVersion();
		if ( declaredVersion != null ) {
					.buildVersionAttributejpaMappingTypedeclaredVersion )
			);
		}
	}
	private <X> Set<SingularAttribute<? super X, ?>> buildIdClassAttributes(
			Iterator<PropertypropertyIterator) {
		.trace("Building old-school composite identifier [" + ownerType.getJavaType().getName() + "]");
		Set<SingularAttribute<? super X, ?>> attributesnew HashSet<SingularAttribute<? super X, ?>>();
		while ( propertyIterator.hasNext() ) {
			attributes.add.buildIdAttributeownerTypepropertyIterator.next() ) );
		}
		return attributes;
	}
	private <X> void populateStaticMetamodel(AbstractManagedType<X> managedType) {
		final Class<X> managedTypeClass = managedType.getJavaType();
		final String metamodelClassName = managedTypeClass.getName() + "_";
		try {
			final Class metamodelClass = Class.forNamemetamodelClassNametruemanagedTypeClass.getClassLoader() );
			// we found the class; so populate it...
			registerAttributesmetamodelClassmanagedType );
		}
		catch ( ClassNotFoundException ignore ) {
			// nothing to do...
		}
		// todo : this does not account for @MappeSuperclass, mainly because this is not being tracked in our
		// internal metamodel as populated from the annotatios properly
		AbstractManagedType<? super X> superType = managedType.getSupertype();
		if ( superType != null ) {
		}
	}
	private final Set<ClassprocessedMetamodelClasses = new HashSet<Class>();
	private <X> void registerAttributes(Class metamodelClassAbstractManagedType<X> managedType) {
		if ( ! .addmetamodelClass ) ) {
			return;
		}
		// push the attributes on to the metamodel class...
		for ( Attribute<X, ?> attribute : managedType.getDeclaredAttributes() ) {
			registerAttributemetamodelClassattribute );
		}
		if ( IdentifiableType.class.isInstancemanagedType ) ) {
			final AbstractIdentifiableType<X> entityType = ( AbstractIdentifiableType<X> ) managedType;
			// handle version
			if ( entityType.hasDeclaredVersionAttribute() ) {
				registerAttributemetamodelClassentityType.getDeclaredVersion() );
			}
			// handle id-class mappings specially
			if ( ! entityType.hasSingleIdAttribute() ) {
				final Set<SingularAttribute<? super X, ?>> attributes = entityType.getIdClassAttributes();
				if ( attributes != null ) {
					for ( SingularAttribute<? super X, ?> attribute : attributes ) {
						registerAttributemetamodelClassattribute );
					}
				}
			}
		}
	}
	private <X> void registerAttribute(Class metamodelClassAttribute<X, ?> attribute) {
		final String name = attribute.getName();
		try {
			// there is a shortcoming in the existing Hibernate code in terms of the way MappedSuperclass
			// support was bolted on which comes to bear right here when the attribute is an embeddable type
			// defined on a MappedSuperclass.  We do not have the correct information to determine the
			// appropriate attribute declarer in such cases and so the incoming metamodelClass most likely
			// does not represent the declarer in such cases.
			//
			// As a result, in the case of embeddable classes we simply use getField rather than get
			// getDeclaredField
metamodelClass.getFieldname )
metamodelClass.getDeclaredFieldname );
			try {
				if ( ! field.isAccessible() ) {
					// should be public anyway, but to be sure...
					field.setAccessibletrue );
				}
				field.setnullattribute );
			}
			catch ( IllegalAccessException e ) {
				// todo : exception type?
				throw new AssertionFailure(
						"Unable to inject static metamodel attribute : " + metamodelClass.getName() + '#' + name,
						e
				);
			}
			catch ( IllegalArgumentException e ) {
				// most likely a mismatch in the type we are injecting and the defined field; this represents a
				// mismatch in how the annotation processor interpretted the attribute and how our metamodel
				// and/or annotation binder did.
//              This is particularly the case as arrays are nto handled propery by the StaticMetamodel generator
//				throw new AssertionFailure(
//						"Illegal argument on static metamodel field injection : " + metamodelClass.getName() + '#' + name
//								+ "; expected type :  " + attribute.getClass().getName()
//								+ "; encountered type : " + field.getType().getName()
//				);
                .illegalArgumentOnStaticMetamodelFieldInjection(metamodelClass.getName(),
                                                                   name,
                                                                   attribute.getClass().getName(),
                                                                   field.getType().getName());
			}
		}
		catch ( NoSuchFieldException e ) {
            .unableToLocateStaticMetamodelField(metamodelClass.getName(), name);
//			throw new AssertionFailure(
//					"Unable to locate static metamodel field : " + metamodelClass.getName() + '#' + name
//			);
		}
	}
	}
	public void pushEntityWorkedOn(PersistentClass persistentClass) {
	}
	public void popEntityWorkedOn(PersistentClass persistentClass) {
		);
		if (stackTop != persistentClass) {
			throw new AssertionFailure"Inconsistent popping: "
persistentClass.getEntityName() + " instead of " + stackTop.getEntityName() );
		}
	}
			);
	}
		final PersistentClass persistentClass = .getmappedSuperclassType );
		if (persistentClass == null) {
			throw new AssertionFailure"Could not find PersistentClass for MappedSuperclassType: "
mappedSuperclassType.getJavaType() );
		}
		return persistentClass;
	}
New to GrepCode? Check out our FAQ X