public EntityMetamodel(PersistentClass persistentClass,
    SessionFactoryImplementor sessionFactory) 
{
		this.sessionFactory = sessionFactory;
		name = persistentClass.getEntityName();
		rootName = persistentClass.getRootClass().getEntityName();
		entityType = TypeFactory.manyToOne( name );
		identifierProperty = PropertyFactory.buildIdentifierProperty(
		        persistentClass,
		        sessionFactory.getIdentifierGenerator( rootName )
			);
		versioned = persistentClass.isVersioned();
		boolean lazyAvailable = persistentClass.hasPojoRepresentation() &&
		                        FieldInterceptionHelper.isInstrumented( persistentClass.getMappedClass() );
		boolean hasLazy = false;
		propertySpan = persistentClass.getPropertyClosureSpan();
		properties = new StandardProperty[propertySpan];
		List naturalIdNumbers = new ArrayList();
		// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		propertyNames = new String[propertySpan];
		propertyTypes = new Type[propertySpan];
		propertyUpdateability = new boolean[propertySpan];
		propertyInsertability = new boolean[propertySpan];
		insertInclusions = new ValueInclusion[propertySpan];
		updateInclusions = new ValueInclusion[propertySpan];
		nonlazyPropertyUpdateability = new boolean[propertySpan];
		propertyCheckability = new boolean[propertySpan];
		propertyNullability = new boolean[propertySpan];
		propertyVersionability = new boolean[propertySpan];
		propertyLaziness = new boolean[propertySpan];
		cascadeStyles = new CascadeStyle[propertySpan];
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		Iterator iter = persistentClass.getPropertyClosureIterator();
		int i = 0;
		int tempVersionProperty = NO_VERSION_INDX;
		boolean foundCascade = false;
		boolean foundCollection = false;
		boolean foundMutable = false;
		boolean foundNonIdentifierPropertyNamedId = false;
		boolean foundInsertGeneratedValue = false;
		boolean foundUpdateGeneratedValue = false;
		boolean foundUpdateableNaturalIdProperty = false;
		while ( iter.hasNext() ) {
			Property prop = ( Property ) iter.next();
			if ( prop == persistentClass.getVersion() ) {
				tempVersionProperty = i;
				properties[i] = PropertyFactory.buildVersionProperty( prop, lazyAvailable );
			}
			else {
				properties[i] = PropertyFactory.buildStandardProperty( prop, lazyAvailable );
			}
			if ( prop.isNaturalIdentifier() ) {
				naturalIdNumbers.add( new Integer(i) );
				if ( prop.isUpdateable() ) {
					foundUpdateableNaturalIdProperty = true;
				}
			}
			if ( "id".equals( prop.getName() ) ) {
				foundNonIdentifierPropertyNamedId = true;
			}
			// temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			boolean lazy = prop.isLazy() && lazyAvailable;
			if ( lazy ) hasLazy = true;
			propertyLaziness[i] = lazy;
			propertyNames[i] = properties[i].getName();
			propertyTypes[i] = properties[i].getType();
			propertyNullability[i] = properties[i].isNullable();
			propertyUpdateability[i] = properties[i].isUpdateable();
			propertyInsertability[i] = properties[i].isInsertable();
			insertInclusions[i] = determineInsertValueGenerationType( prop, properties[i] );
			updateInclusions[i] = determineUpdateValueGenerationType( prop, properties[i] );
			propertyVersionability[i] = properties[i].isVersionable();
			nonlazyPropertyUpdateability[i] = properties[i].isUpdateable() && !lazy;
			propertyCheckability[i] = propertyUpdateability[i] ||
					( propertyTypes[i].isAssociationType() && ( (AssociationType) propertyTypes[i] ).isAlwaysDirtyChecked() );
			cascadeStyles[i] = properties[i].getCascadeStyle();
			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			if ( properties[i].isLazy() ) {
				hasLazy = true;
			}
			if ( properties[i].getCascadeStyle() != CascadeStyle.NONE ) {
				foundCascade = true;
			}
			if ( indicatesCollection( properties[i].getType() ) ) {
				foundCollection = true;
			}
			if ( propertyTypes[i].isMutable() && propertyCheckability[i] ) {
				foundMutable = true;
			}
			if ( insertInclusions[i] != ValueInclusion.NONE ) {
				foundInsertGeneratedValue = true;
			}
			if ( updateInclusions[i] != ValueInclusion.NONE ) {
				foundUpdateGeneratedValue = true;
			}
			mapPropertyToIndex(prop, i);
			i++;
		}
		if (naturalIdNumbers.size()==0) {
			naturalIdPropertyNumbers = null;
			hasImmutableNaturalId = false;
		}
		else {
			naturalIdPropertyNumbers = ArrayHelper.toIntArray(naturalIdNumbers);
			hasImmutableNaturalId = !foundUpdateableNaturalIdProperty;
		}
		hasInsertGeneratedValues = foundInsertGeneratedValue;
		hasUpdateGeneratedValues = foundUpdateGeneratedValue;
		hasCascades = foundCascade;
		hasNonIdentifierPropertyNamedId = foundNonIdentifierPropertyNamedId;
		versionPropertyIndex = tempVersionProperty;
		hasLazyProperties = hasLazy;
		if ( hasLazyProperties ) {
			log.info( "lazy property fetching available for: " + name );
		}
		lazy = persistentClass.isLazy() && (
				// TODO: this disables laziness even in non-pojo entity modes:
				!persistentClass.hasPojoRepresentation() ||
				!ReflectHelper.isFinalClass( persistentClass.getProxyInterface() )
		);
		mutable = persistentClass.isMutable();
		if ( persistentClass.isAbstract() == null ) {
			// legacy behavior (with no abstract attribute specified)
			isAbstract = persistentClass.hasPojoRepresentation() &&
			             ReflectHelper.isAbstractClass( persistentClass.getMappedClass() );
		}
		else {
			isAbstract = persistentClass.isAbstract().booleanValue();
			if ( !isAbstract && persistentClass.hasPojoRepresentation() &&
			     ReflectHelper.isAbstractClass( persistentClass.getMappedClass() ) ) {
				log.warn( "entity [" + name + "] is abstract-class/interface explicitly mapped as non-abstract; be sure to supply entity-names" );
			}
		}
		selectBeforeUpdate = persistentClass.hasSelectBeforeUpdate();
		dynamicUpdate = persistentClass.useDynamicUpdate();
		dynamicInsert = persistentClass.useDynamicInsert();
		polymorphic = persistentClass.isPolymorphic();
		explicitPolymorphism = persistentClass.isExplicitPolymorphism();
		inherited = persistentClass.isInherited();
		superclass = inherited ?
				persistentClass.getSuperclass().getEntityName() :
				null;
		hasSubclasses = persistentClass.hasSubclasses();
		optimisticLockMode = persistentClass.getOptimisticLockMode();
		if ( optimisticLockMode  > Versioning.OPTIMISTIC_LOCK_VERSION && !dynamicUpdate ) {
			throw new MappingException( "optimistic-lock=all|dirty requires dynamic-update=\"true\": " + name );
		}
		if ( versionPropertyIndex != NO_VERSION_INDX && optimisticLockMode  > Versioning.OPTIMISTIC_LOCK_VERSION ) {
			throw new MappingException( "version and optimistic-lock=all|dirty are not a valid combination : " + name );
		}
		hasCollections = foundCollection;
		hasMutableProperties = foundMutable;
		iter = persistentClass.getSubclassIterator();
		while ( iter.hasNext() ) {
			subclassEntityNames.add( ( (PersistentClass) iter.next() ).getEntityName() );
		}
		subclassEntityNames.add( name );
		tuplizerMapping = new EntityEntityModeToTuplizerMapping( persistentClass, this );
}

 public CascadeStyle[] getCascadeStyles() 
{
		return cascadeStyles;
}

 public EntityType getEntityType() 
{
		return entityType;
}

 public IdentifierProperty getIdentifierProperty() 
{
		return identifierProperty;
}

 public String getName() 
{
		return name;
}

 public int[] getNaturalIdentifierProperties() 
{
		return naturalIdPropertyNumbers;
}

 public boolean[] getNonlazyPropertyUpdateability() 
{
		return nonlazyPropertyUpdateability;
}

 public int getOptimisticLockMode() 
{
		return optimisticLockMode;
}

 public StandardProperty[] getProperties() 
{
		return properties;
}

 public boolean[] getPropertyCheckability() 
{
		return propertyCheckability;
}

 public int getPropertyIndex(String propertyName) 
{
		Integer index = getPropertyIndexOrNull(propertyName);
		if ( index == null ) {
			throw new HibernateException("Unable to resolve property: " + propertyName);
		}
		return index.intValue();
}

 public Integer getPropertyIndexOrNull(String propertyName) 
{
		return (Integer) propertyIndexes.get( propertyName );
}

 public ValueInclusion[] getPropertyInsertGenerationInclusions() 
{
		return insertInclusions;
}

 public boolean[] getPropertyInsertability() 
{
		return propertyInsertability;
}

 public boolean[] getPropertyLaziness() 
{
		return propertyLaziness;
}

 public String[] getPropertyNames() 
{
		return propertyNames;
}

 public boolean[] getPropertyNullability() 
{
		return propertyNullability;
}

 public int getPropertySpan() 
{
		return propertySpan;
}

 public Type[] getPropertyTypes() 
{
		return propertyTypes;
}

 public ValueInclusion[] getPropertyUpdateGenerationInclusions() 
{
		return updateInclusions;
}

 public boolean[] getPropertyUpdateability() 
{
		return propertyUpdateability;
}

 public boolean[] getPropertyVersionability() 
{
		return propertyVersionability;
}

 public String getRootName() 
{
		return rootName;
}

 public SessionFactoryImplementor getSessionFactory() 
{
		return sessionFactory;
}

 public Set getSubclassEntityNames() 
{
		return subclassEntityNames;
}

 public String getSuperclass() 
{
		return superclass;
}

 public EntityTuplizer getTuplizer(EntityMode entityMode) 
{
	    
		return (EntityTuplizer) tuplizerMapping.getTuplizer( entityMode );
}

 public EntityTuplizer getTuplizerOrNull(EntityMode entityMode) 
{
		return ( EntityTuplizer ) tuplizerMapping.getTuplizerOrNull( entityMode );
}

 public VersionProperty getVersionProperty() 
{
		if ( NO_VERSION_INDX == versionPropertyIndex ) {
			return null;
		}
		else {
			return ( VersionProperty ) properties[ versionPropertyIndex ];
		}
}

 public int getVersionPropertyIndex() 
{
		return versionPropertyIndex;
}

 public EntityMode guessEntityMode(Object object) 
{
		return tuplizerMapping.guessEntityMode( object );
}

 public boolean hasCascades() 
{
		return hasCascades;
}

 public boolean hasCollections() 
{
		return hasCollections;
}

 public boolean hasImmutableNaturalId() 
{
		return hasImmutableNaturalId;
}

 public boolean hasInsertGeneratedValues() 
{
		return hasInsertGeneratedValues;
}

 public boolean hasLazyProperties() 
{
		return hasLazyProperties;
}

 public boolean hasMutableProperties() 
{
		return hasMutableProperties;
}

 public boolean hasNaturalIdentifier() 
{
		return naturalIdPropertyNumbers!=null;
}

 public boolean hasNonIdentifierPropertyNamedId() 
{
		return hasNonIdentifierPropertyNamedId;
}

 public boolean hasSubclasses() 
{
		return hasSubclasses;
}

 public boolean hasUpdateGeneratedValues() 
{
		return hasUpdateGeneratedValues;
}

 public boolean isAbstract() 
{
		return isAbstract;
}

 public boolean isDynamicInsert() 
{
		return dynamicInsert;
}

 public boolean isDynamicUpdate() 
{
		return dynamicUpdate;
}

 public boolean isExplicitPolymorphism() 
{
		return explicitPolymorphism;
}

 public boolean isInherited() 
{
		return inherited;
}

 public boolean isLazy() 
{
		return lazy;
}

 public boolean isMutable() 
{
		return mutable;
}

 public boolean isPolymorphic() 
{
		return polymorphic;
}

 public boolean isSelectBeforeUpdate() 
{
		return selectBeforeUpdate;
}

 public boolean isVersioned() 
{
		return versioned;
}

 public  void setLazy(boolean lazy) 
{
		this.lazy = lazy;
}

 public String toString() 
{
		return "EntityMetamodel(" + name + ':" + ArrayHelper.toString(properties) + ')";
}