import org.hibernate.AssertionFailure; //导入依赖的package包/类
public void addAttributeConverter(AttributeConverterDefinition definition) {
	if ( attributeConverterDefinitionsByClass == null ) {
		attributeConverterDefinitionsByClass = new ConcurrentHashMap<Class, AttributeConverterDefinition>();
	}

	final Object old = attributeConverterDefinitionsByClass.put( definition.getAttributeConverter().getClass(), definition );

	if ( old != null ) {
		throw new AssertionFailure(
				String.format(
						"AttributeConverter class [%s] registered multiple times",
						definition.getAttributeConverter().getClass()
				)
		);
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public void doSecondPass(java.util.Map persistentClasses) throws MappingException {
	if ( value instanceof ManyToOne ) {
		ManyToOne manyToOne = (ManyToOne) value;
		PersistentClass ref = (PersistentClass) persistentClasses.get( manyToOne.getReferencedEntityName() );
		if ( ref == null ) {
			throw new AnnotationException(
					"@OneToOne or @ManyToOne on "
							+ StringHelper.qualify( entityClassName, path )
							+ " references an unknown entity: "
							+ manyToOne.getReferencedEntityName()
			);
		}
		BinderHelper.createSyntheticPropertyReference( columns, ref, null, manyToOne, false, mappings );
		TableBinder.bindFk( ref, null, columns, manyToOne, unique, mappings );
		/*
		 * HbmMetadataSourceProcessorImpl does this only when property-ref != null, but IMO, it makes sense event if it is null
		 */
		if ( !manyToOne.isIgnoreNotFound() ) manyToOne.createPropertyRefConstraints( persistentClasses );
	}
	else if ( value instanceof OneToOne ) {
		value.createForeignKey();
	}
	else {
		throw new AssertionFailure( "FkSecondPass for a wrong value type: " + value.getClass().getName() );
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public static MappedSuperclass getMappedSuperclassOrNull(
		XClass declaringClass,
		Map<XClass, InheritanceState> inheritanceStatePerClass,
		Mappings mappings) {
	boolean retrieve = false;
	if ( declaringClass != null ) {
		final InheritanceState inheritanceState = inheritanceStatePerClass.get( declaringClass );
		if ( inheritanceState == null ) {
			throw new org.hibernate.annotations.common.AssertionFailure(
					"Declaring class is not found in the inheritance state hierarchy: " + declaringClass
			);
		}
		if ( inheritanceState.isEmbeddableSuperclass() ) {
			retrieve = true;
		}
	}
	return retrieve ?
			mappings.getMappedSuperclass( mappings.getReflectionManager().toClass( declaringClass ) ) :
	        null;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private static PersistentClass getSuperEntity(XClass clazzToProcess, Map<XClass, InheritanceState> inheritanceStatePerClass, Mappings mappings, InheritanceState inheritanceState) {
	InheritanceState superEntityState = InheritanceState.getInheritanceStateOfSuperEntity(
			clazzToProcess, inheritanceStatePerClass
	);
	PersistentClass superEntity = superEntityState != null ?
			mappings.getClass(
					superEntityState.getClazz().getName()
			) :
			null;
	if ( superEntity == null ) {
		//check if superclass is not a potential persistent class
		if ( inheritanceState.hasParents() ) {
			throw new AssertionFailure(
					"Subclass has to be binded after it's mother class: "
							+ superEntityState.getClazz().getName()
			);
		}
	}
	return superEntity;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private static void bindDiscriminatorColumnToRootPersistentClass(
		RootClass rootClass,
		Ejb3DiscriminatorColumn discriminatorColumn,
		Map<String, Join> secondaryTables,
		PropertyHolder propertyHolder,
		Mappings mappings) {
	if ( rootClass.getDiscriminator() == null ) {
		if ( discriminatorColumn == null ) {
			throw new AssertionFailure( "discriminator column should have been built" );
		}
		discriminatorColumn.setJoins( secondaryTables );
		discriminatorColumn.setPropertyHolder( propertyHolder );
		SimpleValue discriminatorColumnBinding = new SimpleValue( mappings, rootClass.getTable() );
		rootClass.setDiscriminator( discriminatorColumnBinding );
		discriminatorColumn.linkWithValue( discriminatorColumnBinding );
		discriminatorColumnBinding.setTypeName( discriminatorColumn.getDiscriminatorTypeName() );
		rootClass.setPolymorphic( true );
		if ( LOG.isTraceEnabled() ) {
			LOG.tracev( "Setting discriminator for entity {0}", rootClass.getEntityName() );
		}
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
/**
 * Removes a persistent collection from its loaded owner.
 *
 * Use this constructor when the collection is non-null.
 *
 * @param collection The collection to to remove; must be non-null
 * @param persister  The collection's persister
 * @param id The collection key
 * @param emptySnapshot Indicates if the snapshot is empty
 * @param session The session
 *
 * @throws AssertionFailure if collection is null.
 */
public CollectionRemoveAction(
			final PersistentCollection collection,
			final CollectionPersister persister,
			final Serializable id,
			final boolean emptySnapshot,
			final SessionImplementor session) {
	super( persister, collection, id, session );
	if ( collection == null ) {
		throw new AssertionFailure("collection == null");
	}
	this.emptySnapshot = emptySnapshot;
	// the loaded owner will be set to null after the collection is removed,
	// so capture its value as the affected owner so it is accessible to
	// both pre- and post- events
	this.affectedOwner = session.getPersistenceContext().getLoadedCollectionOwnerOrNull( collection );
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private static CacheMode getCacheMode(CacheModeType cacheModeType) {
	switch ( cacheModeType ) {
		case GET:
			return CacheMode.GET;
		case IGNORE:
			return CacheMode.IGNORE;
		case NORMAL:
			return CacheMode.NORMAL;
		case PUT:
			return CacheMode.PUT;
		case REFRESH:
			return CacheMode.REFRESH;
		default:
			throw new AssertionFailure( "Unknown cacheModeType: " + cacheModeType );
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public TableSpecification locateTable(String tableName) {
    if ( tableName == null || tableName.equals( getPrimaryTableName() ) ) {
        return primaryTable;
    }
    TableSpecification tableSpec = secondaryTables.get( tableName );
    if ( tableSpec == null ) {
        throw new AssertionFailure(
                String.format(
                        "Unable to find table %s amongst tables %s",
                        tableName,
                        secondaryTables.keySet()
                )
        );
    }
    return tableSpec;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
@Override
public Object[] extractNaturalIdValues(Object entity, EntityPersister persister) {
	if ( entity == null ) {
		throw new AssertionFailure( "Entity from which to extract natural id value(s) cannot be null" );
	}
	if ( persister == null ) {
		throw new AssertionFailure( "Persister to use in extracting natural id value(s) cannot be null" );
	}

	final int[] naturalIdentifierProperties = persister.getNaturalIdentifierProperties();
	final Object[] naturalIdValues = new Object[naturalIdentifierProperties.length];

	for ( int i = 0; i < naturalIdentifierProperties.length; i++ ) {
		naturalIdValues[i] = persister.getPropertyValue( entity, naturalIdentifierProperties[i] );
	}

	return naturalIdValues;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private EntityBinding createBasicEntityBinding(EntitySource entitySource, EntityBinding superEntityBinding) {
	if ( superEntityBinding == null ) {
		return makeRootEntityBinding( (RootEntitySource) entitySource );
	}
	else {
		switch ( currentInheritanceType ) {
			case SINGLE_TABLE:
				return makeDiscriminatedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			case JOINED:
				return makeJoinedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			case TABLE_PER_CLASS:
				return makeUnionedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			default:
				// extreme internal error!
				throw new AssertionFailure( "Internal condition failure" );
		}
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
void resolve() {
	for ( EntityBinding entityBinding : metadata.getEntityBindings() ) {
		if ( entityBinding.getHierarchyDetails().getEntityDiscriminator() != null ) {
			resolveDiscriminatorTypeInformation( entityBinding.getHierarchyDetails().getEntityDiscriminator() );
		}
		for ( AttributeBinding attributeBinding : entityBinding.attributeBindings() ) {
			if ( SingularAttributeBinding.class.isInstance( attributeBinding ) ) {
				resolveSingularAttributeTypeInformation(
						SingularAttributeBinding.class.cast( attributeBinding  )
				);
			}
			else if ( AbstractPluralAttributeBinding.class.isInstance( attributeBinding ) ) {
				resolvePluralAttributeTypeInformation(
						AbstractPluralAttributeBinding.class.cast( attributeBinding )
				);
			}
			else {
				throw new AssertionFailure( "Unknown type of AttributeBinding: " + attributeBinding.getClass().getName() );
			}
		}
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private void resolveSingularAttributeTypeInformation(SingularAttributeBinding attributeBinding) {
	if ( attributeBinding.getHibernateTypeDescriptor().getResolvedTypeMapping() != null ) {
		return;
	}
	// we can determine the Hibernate Type if either:
	// 		1) the user explicitly named a Type in a HibernateTypeDescriptor
	// 		2) we know the java type of the attribute
	Type resolvedType;
	resolvedType = determineSingularTypeFromDescriptor( attributeBinding.getHibernateTypeDescriptor() );
	if ( resolvedType == null ) {
		if ( ! attributeBinding.getAttribute().isSingular() ) {
			throw new AssertionFailure( "SingularAttributeBinding object has a plural attribute: " + attributeBinding.getAttribute().getName() );
		}
		final SingularAttribute singularAttribute = ( SingularAttribute ) attributeBinding.getAttribute();
		if ( singularAttribute.getSingularAttributeType() != null ) {
			resolvedType = getHeuristicType(
					singularAttribute.getSingularAttributeType().getClassName(), new Properties()
			);
		}
	}
	if ( resolvedType != null ) {
		pushHibernateTypeInformationDownIfNeeded( attributeBinding, resolvedType );
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
@Override
public IdentifierSource getIdentifierSource() {
	IdType idType = getEntityClass().getIdType();
	switch ( idType ) {
		case SIMPLE: {
			BasicAttribute attribute = getEntityClass().getIdAttributes().iterator().next();
			return new SimpleIdentifierSourceImpl( attribute, getEntityClass().getAttributeOverrideMap() );
		}
		case COMPOSED: {
			throw new NotYetImplementedException( "Composed ids must still be implemented." );
		}
		case EMBEDDED: {
			throw new NotYetImplementedException( "Embedded ids must still be implemented." );
		}
		default: {
			throw new AssertionFailure( "The root entity needs to specify an identifier" );
		}
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public AttributeOverride(String prefix, AnnotationInstance attributeOverrideAnnotation) {
	if ( attributeOverrideAnnotation == null ) {
		throw new IllegalArgumentException( "An AnnotationInstance needs to be passed" );
	}

	if ( !JPADotNames.ATTRIBUTE_OVERRIDE.equals( attributeOverrideAnnotation.name() ) ) {
		throw new AssertionFailure( "A @AttributeOverride annotation needs to be passed to the constructor" );
	}

	columnValues = new ColumnValues(
			JandexHelper.getValue(
					attributeOverrideAnnotation,
					"column",
					AnnotationInstance.class
			)
	);
	attributePath = createAttributePath(
			prefix,
			JandexHelper.getValue( attributeOverrideAnnotation, "name", String.class )
	);
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public void afterTransactionCompletion(boolean success) {
	while ( !processes.isEmpty() ) {
		try {
			processes.poll().doAfterTransactionCompletion( success, session );
		}
		catch (CacheException ce) {
			LOG.unableToReleaseCacheLock( ce );
			// continue loop
		}
		catch (Exception e) {
			throw new AssertionFailure( "Exception releasing cache locks", e );
		}
	}

	if ( session.getFactory().getSettings().isQueryCacheEnabled() ) {
		session.getFactory().getUpdateTimestampsCache().invalidate(
				querySpacesToInvalidate.toArray( new String[querySpacesToInvalidate.size()] ),
				session
		);
	}
	querySpacesToInvalidate.clear();
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
@Override
protected Map<String, String> resolveHibernateTypeParameters(AnnotationInstance annotationInstance) {
	HashMap<String, String> typeParameters = new HashMap<String, String>();
	typeParameters.put( EnumType.ENUM, mappedAttribute.getAttributeType().getName() );
	if ( annotationInstance != null ) {
		javax.persistence.EnumType enumType = JandexHelper.getEnumValue(
				annotationInstance,
				"value",
				javax.persistence.EnumType.class
		);
		if ( javax.persistence.EnumType.ORDINAL.equals( enumType ) ) {
			typeParameters.put( EnumType.TYPE, String.valueOf( Types.INTEGER ) );
		}
		else if ( javax.persistence.EnumType.STRING.equals( enumType ) ) {
			typeParameters.put( EnumType.TYPE, String.valueOf( Types.VARCHAR ) );
		}
		else {
			throw new AssertionFailure( "Unknown EnumType: " + enumType );
		}
	}
	else {
		typeParameters.put( EnumType.TYPE, String.valueOf( Types.INTEGER ) );
	}
	return typeParameters;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
@Override
public void entityCopyDetected(
		Object managedEntity,
		Object mergeEntity1,
		Object mergeEntity2,
		EventSource session) {
	if ( mergeEntity1 == managedEntity && mergeEntity2 == managedEntity) {
		throw new AssertionFailure( "entity1 and entity2 are the same as managedEntity; must be different." );
	}
	final String managedEntityString = 	MessageHelper.infoString(
			session.getEntityName( managedEntity ),
			session.getIdentifier( managedEntity )
	);
	throw new IllegalStateException(
			"Multiple representations of the same entity " + managedEntityString + " are being merged. " +
					getManagedOrDetachedEntityString( managedEntity, mergeEntity1 ) + "; " +
					getManagedOrDetachedEntityString( managedEntity, mergeEntity2 )
	);
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
private EnumState(int offset, Class<E> enumType) {
	E[] enumConstants = enumType.getEnumConstants();

	// In case any of the enums cannot be stored in 4 bits anymore, we'd have to re-structure the compressed
	// state int
	if ( enumConstants.length > 15 ) {
		throw new AssertionFailure( "Cannot store enum type " + enumType.getName() + " in compressed state as"
				+ " it has too many values." );
	}

	this.offset = offset;
	this.enumConstants = enumConstants;

	// a mask for reading the four bits, starting at the right offset
	this.mask = 0xF << offset;

	// a mask for setting the four bits at the right offset to 0
	this.unsetMask = 0xFFFF & ~mask;
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
/**
 * @param annotations List of annotation instances keyed against their dot name.
 * @param annotationName the annotation to retrieve from map
 *
 * @return the single annotation of the specified dot name or {@code null} in case the annotation is not specified at all
 *
 * @throws org.hibernate.AssertionFailure in case there is there is more than one annotation of this type.
 */
public static AnnotationInstance getSingleAnnotation(Map<DotName, List<AnnotationInstance>> annotations, DotName annotationName)
		throws AssertionFailure {
	List<AnnotationInstance> annotationList = annotations.get( annotationName );
	if ( annotationList == null ) {
		return null;
	}
	else if ( annotationList.size() == 1 ) {
		return annotationList.get( 0 );
	}
	else {
		throw new AssertionFailure(
				"Found more than one instance of the annotation "
						+ annotationList.get( 0 ).name().toString()
						+ ". Expected was one."
		);
	}
}
 

import org.hibernate.AssertionFailure; //导入依赖的package包/类
public static String generationTypeToGeneratorStrategyName(GenerationType generatorEnum, boolean useNewGeneratorMappings) {
	switch ( generatorEnum ) {
		case IDENTITY:
			return "identity";
		case AUTO:
			return useNewGeneratorMappings
					? "enhanced-sequence"
					: "native";
		case TABLE:
			return useNewGeneratorMappings
					? "enhanced-table"
					: MultipleHiLoPerTableGenerator.class.getName();
		case SEQUENCE:
			return useNewGeneratorMappings
					? "enhanced-sequence"
					: "seqhilo";
	}
	throw new AssertionFailure( "Unknown GeneratorType: " + generatorEnum );
}