## Uses of Interface
org.hibernate.persister.entity.EntityPersister

Packages that use EntityPersister
org.hibernate: This package defines the central Hibernate APIs.
org.hibernate.action.internal
org.hibernate.cache.internal
org.hibernate.cache.spi: Defines the Hibernate second level caching SPI.
org.hibernate.cache.spi.entry: This package defines formats for disassembled state kept in the second level cache.
org.hibernate.cfg.beanvalidation
org.hibernate.ejb.event
org.hibernate.engine.internal
org.hibernate.engine.profile
org.hibernate.engine.spi
org.hibernate.envers.entities.mapper.relation.lazy
org.hibernate.envers.event
org.hibernate.envers.synchronization.work
org.hibernate.event.internal: This package defines a default set of event listeners that implements the default behaviors of Hibernate.
org.hibernate.event.spi
org.hibernate.hql.internal.ast.tree
org.hibernate.hql.internal.ast.util
org.hibernate.id: This package contains internal implementation classes for the main API interfaces.
org.hibernate.internal: An internal package containing mostly implementations of central Hibernate APIs.
org.hibernate.loader: This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects.
org.hibernate.loader.entity: This package defines entity loaders
org.hibernate.metamodel.binding
org.hibernate.persister.collection: This package abstracts the persistence mechanism for collections.
org.hibernate.persister.entity: This package abstracts persistence mechanisms for entities, and defines the Hibernate runtime metamodel.
org.hibernate.persister.internal
org.hibernate.persister.spi
org.hibernate.pretty: Classes for pretty printing things for exception and log messages.

Uses of EntityPersister in org.hibernate

Methods in org.hibernate that return EntityPersister
`EntityPersister` `CustomEntityDirtinessStrategy.AttributeInformation.getContainingPersister()` Get a reference to the persister for the entity containing this attribute.

Methods in org.hibernate with parameters of type EntityPersister

`boolean`

`CustomEntityDirtinessStrategy.canDirtyCheck(Object entity, EntityPersister persister, Session session)`
Is this strategy capable of telling whether the given entity is dirty? A return of `true` means that `CustomEntityDirtinessStrategy.isDirty(java.lang.Object, org.hibernate.persister.entity.EntityPersister, org.hibernate.Session)` will be called next as the definitive means to determine whether the entity is dirty.

`void` `CustomEntityDirtinessStrategy.findDirty(Object entity, EntityPersister persister, Session session, CustomEntityDirtinessStrategy.DirtyCheckContext dirtyCheckContext)` Callback used to hook into Hibernate algorithm for determination of which attributes have changed.
`boolean` `CustomEntityDirtinessStrategy.isDirty(Object entity, EntityPersister persister, Session session)` The callback used by Hibernate to determine if the given entity is dirty.
`void` `CustomEntityDirtinessStrategy.resetDirty(Object entity, EntityPersister persister, Session session)` Callback used by Hibernate to signal that the entity dirty flag should be cleared.

Uses of EntityPersister in org.hibernate.action.internal

Methods in org.hibernate.action.internal that return EntityPersister
`EntityPersister` `EntityAction.getPersister()` entity persister accessor

Constructors in org.hibernate.action.internal with parameters of type EntityPersister
`AbstractEntityInsertAction(Serializable id, Object[] state, Object instance, boolean isVersionIncrementDisabled, EntityPersister persister, SessionImplementor session)` Constructs an AbstractEntityInsertAction object.
`EntityAction(SessionImplementor session, Serializable id, Object instance, EntityPersister persister)` Instantiate an action.
`EntityDeleteAction(Serializable id, Object[] state, Object version, Object instance, EntityPersister persister, boolean isCascadeDeleteEnabled, SessionImplementor session)`
`EntityIdentityInsertAction(Object[] state, Object instance, EntityPersister persister, boolean isVersionIncrementDisabled, SessionImplementor session, boolean isDelayed)`
`EntityInsertAction(Serializable id, Object[] state, Object instance, Object version, EntityPersister persister, boolean isVersionIncrementDisabled, SessionImplementor session)`
`EntityUpdateAction(Serializable id, Object[] state, int[] dirtyProperties, boolean hasDirtyCollection, Object[] previousState, Object previousVersion, Object nextVersion, Object instance, Object rowId, EntityPersister persister, SessionImplementor session)`

Uses of EntityPersister in org.hibernate.cache.internal

Methods in org.hibernate.cache.internal with parameters of type EntityPersister
`static CacheDataDescriptionImpl` `CacheDataDescriptionImpl.decode(EntityPersister persister)`

Uses of EntityPersister in org.hibernate.cache.spi

Constructors in org.hibernate.cache.spi with parameters of type EntityPersister
`NaturalIdCacheKey(Object[] naturalIdValues, EntityPersister persister, SessionImplementor session)` Construct a new key for a caching natural identifier resolutions into the second level cache.

Uses of EntityPersister in org.hibernate.cache.spi.entry

Methods in org.hibernate.cache.spi.entry with parameters of type EntityPersister
`Object[]` `CacheEntry.assemble(Object instance, Serializable id, EntityPersister persister, Interceptor interceptor, EventSource session)`

Constructors in org.hibernate.cache.spi.entry with parameters of type EntityPersister
`CacheEntry(Object[] state, EntityPersister persister, boolean unfetched, Object version, SessionImplementor session, Object owner)`
`StructuredCacheEntry(EntityPersister persister)`

Uses of EntityPersister in org.hibernate.cfg.beanvalidation

Constructors in org.hibernate.cfg.beanvalidation with parameters of type EntityPersister
`HibernateTraversableResolver(EntityPersister persister, ConcurrentHashMap<EntityPersister,Set<String>> associationsPerEntityPersister, SessionFactoryImplementor factory)`

Constructor parameters in org.hibernate.cfg.beanvalidation with type arguments of type EntityPersister
`HibernateTraversableResolver(EntityPersister persister, ConcurrentHashMap<EntityPersister,Set<String>> associationsPerEntityPersister, SessionFactoryImplementor factory)`

Uses of EntityPersister in org.hibernate.ejb.event

Methods in org.hibernate.ejb.event with parameters of type EntityPersister
`protected boolean` `EJB3DeleteEventListener.invokeDeleteLifecycle(EventSource session, Object entity, EntityPersister persister)`
`protected boolean` `EJB3FlushEntityEventListener.invokeInterceptor(SessionImplementor session, Object entity, EntityEntry entry, Object[] values, EntityPersister persister)`

Uses of EntityPersister in org.hibernate.engine.internal

Methods in org.hibernate.engine.internal that return EntityPersister
`protected EntityPersister` `NaturalIdXrefDelegate.locatePersisterForKey(EntityPersister persister)` It is only valid to define natural ids at the root of an entity hierarchy.

Methods in org.hibernate.engine.internal with parameters of type EntityPersister
`EntityEntry` `StatefulPersistenceContext.addEntity(Object entity, Status status, Object[] loadedState, EntityKey entityKey, Object version, LockMode lockMode, boolean existsInDatabase, EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)` Adds an entity to the internal caches.
`EntityEntry` `StatefulPersistenceContext.addEntry(Object entity, Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)` Generates an appropriate EntityEntry instance and adds it to the event source's internal caches.
`static void` `TwoPhaseLoad.addUninitializedCachedEntity(EntityKey key, Object object, EntityPersister persister, LockMode lockMode, boolean lazyPropertiesAreUnfetched, Object version, SessionImplementor session)`
`static void` `TwoPhaseLoad.addUninitializedEntity(EntityKey key, Object object, EntityPersister persister, LockMode lockMode, boolean lazyPropertiesAreUnfetched, SessionImplementor session)` Add an uninitialized instance of an entity class, as a placeholder to ensure object identity.
`boolean` `NaturalIdXrefDelegate.cacheNaturalIdCrossReference(EntityPersister persister, Serializable pk, Object[] naturalIdValues)` Creates needed cross-reference entries between the given primary (pk) and natural (naturalIdValues) key values for the given persister.
`void` `Cascade.cascade(EntityPersister persister, Object parent)` Cascade an action from the parent entity instance to all its children.
`void` `Cascade.cascade(EntityPersister persister, Object parent, Object anything)` Cascade an action from the parent entity instance to all its children.
`void` `Nullability.checkNullability(Object[] values, EntityPersister persister, boolean isUpdate)` Check nullability of the class persister properties
`Object[]` `NaturalIdXrefDelegate.findCachedNaturalId(EntityPersister persister, Serializable pk)` Given a persister and primary key, find the locally cross-referenced natural id.
`Serializable` `NaturalIdXrefDelegate.findCachedNaturalIdResolution(EntityPersister persister, Object[] naturalIdValues)` Given a persister and natural-id value(s), find the locally cross-referenced primary key.
`Collection<Serializable>` `NaturalIdXrefDelegate.getCachedPkResolutions(EntityPersister persister)` Return all locally cross-referenced primary keys for the given persister.
`Object[]` `StatefulPersistenceContext.getDatabaseSnapshot(Serializable id, EntityPersister persister)` Get the current state of the entity as known to the underlying database, or null if there is no corresponding row
`Object[]` `StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)`
`static Object` `Versioning.getVersion(Object[] fields, EntityPersister persister)` Extract the optimistic locking value out of the entity state snapshot.
`protected EntityPersister` `NaturalIdXrefDelegate.locatePersisterForKey(EntityPersister persister)` It is only valid to define natural ids at the root of an entity hierarchy.
`Object` `StatefulPersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)` If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
`static void` `TwoPhaseLoad.postHydrate(EntityPersister persister, Serializable id, Object[] values, Object rowId, Object object, LockMode lockMode, boolean lazyPropertiesAreUnfetched, SessionImplementor session)` Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
`Object` `StatefulPersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)` Return the existing proxy associated with the given `EntityKey`, or the third argument (the entity associated with the key) if no proxy exists.
`void` `StatefulPersistenceContext.registerInsertedKey(EntityPersister persister, Serializable id)`
`Object[]` `NaturalIdXrefDelegate.removeNaturalIdCrossReference(EntityPersister persister, Serializable pk, Object[] naturalIdValues)` Handle removing cross reference entries for the given natural-id/pk combo
`boolean` `NaturalIdXrefDelegate.sameAsCached(EntityPersister persister, Serializable pk, Object[] naturalIdValues)` Are the naturals id values cached here (if any) for the given persister+pk combo the same as the given values?
`static void` `Versioning.setVersion(Object[] fields, Object version, EntityPersister persister)` Inject the optimistic locking value into the entity state snapshot.
`void` `NaturalIdXrefDelegate.stashInvalidNaturalIdReference(EntityPersister persister, Object[] invalidNaturalIdValues)` As part of "load synchronization process", if a particular natural id is found to have changed we need to track its invalidity until after the next flush.
`protected void` `NaturalIdXrefDelegate.validateNaturalId(EntityPersister persister, Object[] naturalIdValues)` Invariant validate of the natural id.
`boolean` `StatefulPersistenceContext.wasInsertedDuringTransaction(EntityPersister persister, Serializable id)`

Uses of EntityPersister in org.hibernate.engine.profile

Methods in org.hibernate.engine.profile that return EntityPersister
`EntityPersister` `Association.getOwner()`

Constructors in org.hibernate.engine.profile with parameters of type EntityPersister
`Association(EntityPersister owner, String associationPath)`

Uses of EntityPersister in org.hibernate.engine.spi

Methods in org.hibernate.engine.spi that return EntityPersister
`EntityPersister` `SessionFactoryImplementor.getEntityPersister(String entityName)` Get the persister for the named entity
`EntityPersister` `SessionImplementor.getEntityPersister(String entityName, Object object)` Get the `EntityPersister` for any instance
`EntityPersister` `EntityEntry.getPersister()`

Methods in org.hibernate.engine.spi with parameters of type EntityPersister
`EntityEntry` `PersistenceContext.addEntity(Object entity, Status status, Object[] loadedState, EntityKey entityKey, Object version, LockMode lockMode, boolean existsInDatabase, EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)` Adds an entity to the internal caches.
`EntityEntry` `PersistenceContext.addEntry(Object entity, Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)` Generates an appropriate EntityEntry instance and adds it to the event source's internal caches.
`void` `PersistenceContext.NaturalIdHelper.cacheNaturalIdCrossReferenceFromLoad(EntityPersister persister, Serializable id, Object[] naturalIdValues)` Performs processing related to creating natural-id cross-reference entries on load.
`Object[]` `PersistenceContext.NaturalIdHelper.extractNaturalIdValues(Object[] state, EntityPersister persister)` Given an array of "full entity state", extract the portions that represent the natural id
`Object[]` `PersistenceContext.NaturalIdHelper.extractNaturalIdValues(Object entity, EntityPersister persister)` Given an entity instance, extract the values that represent the natural id
`Object[]` `PersistenceContext.NaturalIdHelper.findCachedNaturalId(EntityPersister persister, Serializable pk)` Given a persister and primary key, find the corresponding cross-referenced natural id values.
`Serializable` `PersistenceContext.NaturalIdHelper.findCachedNaturalIdResolution(EntityPersister persister, Object[] naturalIdValues)` Given a persister and natural-id values, find the corresponding cross-referenced primary key.
`EntityKey` `SessionImplementor.generateEntityKey(Serializable id, EntityPersister persister)` Hide the changing requirements of entity key creation
`Collection<Serializable>` `PersistenceContext.NaturalIdHelper.getCachedPkResolutions(EntityPersister persister)` Find all the locally cached primary key cross-reference entries for the given persister.
`Object[]` `PersistenceContext.getDatabaseSnapshot(Serializable id, EntityPersister persister)` Get the current state of the entity as known to the underlying database, or null if there is no corresponding row
`Serializable[]` `BatchFetchQueue.getEntityBatch(EntityPersister persister, Serializable id, int batchSize, EntityMode entityMode)` Get a batch of unloaded identifiers for this class, using a slightly complex algorithm that tries to grab keys registered immediately after the given key.
`Object[]` `PersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)` Get the values of the natural id fields as known to the underlying database, or null if the entity has no natural id or there is no corresponding row.
`void` `PersistenceContext.NaturalIdHelper.handleSynchronization(EntityPersister persister, Serializable pk, Object entity)` Part of the "load synchronization process".
`void` `PersistenceContext.NaturalIdHelper.manageLocalNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state, Object[] previousState, CachedNaturalIdValueSource source)` Creates necessary local cross-reference entries.
`void` `PersistenceContext.NaturalIdHelper.manageSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state, Object[] previousState, CachedNaturalIdValueSource source)` Creates necessary shared (second level cache) cross-reference entries.
`Object` `PersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)` If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
`void` `CascadingAction.noCascade(EventSource session, Object child, Object parent, EntityPersister persister, int propertyIndex)` Called (in the case of `CascadingAction.requiresNoCascadeChecking()` returning true) to validate that no cascade on the given property is considered a valid semantic.
`Object` `PersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)` Return the existing proxy associated with the given `EntityKey`, or the third argument (the entity associated with the key) if no proxy exists.
`void` `PersistenceContext.registerInsertedKey(EntityPersister persister, Serializable id)` Register keys inserted during the current transaction
`Object[]` `PersistenceContext.NaturalIdHelper.removeLocalNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state)` Cleans up local cross-reference entries.
`void` `PersistenceContext.NaturalIdHelper.removeSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] naturalIdValues)` Cleans up local cross-reference entries.
`boolean` `PersistenceContext.wasInsertedDuringTransaction(EntityPersister persister, Serializable id)` Allows callers to check to see if the identified entity was inserted during the current transaction.

Constructors in org.hibernate.engine.spi with parameters of type EntityPersister
`EntityEntry(Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EntityPersister persister, EntityMode entityMode, String tenantId, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched, PersistenceContext persistenceContext)`
`EntityKey(Serializable id, EntityPersister persister, String tenantId)` Construct a unique identifier for an entity class instance.

Uses of EntityPersister in org.hibernate.envers.entities.mapper.relation.lazy

Methods in org.hibernate.envers.entities.mapper.relation.lazy that return EntityPersister
`EntityPersister` `AbstractDelegateSessionImplementor.getEntityPersister(String entityName, Object object)`

Methods in org.hibernate.envers.entities.mapper.relation.lazy with parameters of type EntityPersister
`EntityKey` `AbstractDelegateSessionImplementor.generateEntityKey(Serializable id, EntityPersister persister)`

Uses of EntityPersister in org.hibernate.envers.event

Methods in org.hibernate.envers.event with parameters of type EntityPersister
`protected void` `BaseEnversEventListener.generateBidirectionalCollectionChangeWorkUnits(AuditProcess auditProcess, EntityPersister entityPersister, String entityName, Object[] newState, Object[] oldState, SessionImplementor session)`

Uses of EntityPersister in org.hibernate.envers.synchronization.work

Constructors in org.hibernate.envers.synchronization.work with parameters of type EntityPersister
`AddWorkUnit(SessionImplementor sessionImplementor, String entityName, AuditConfiguration verCfg, Serializable id, EntityPersister entityPersister, Object[] state)`
`DelWorkUnit(SessionImplementor sessionImplementor, String entityName, AuditConfiguration verCfg, Serializable id, EntityPersister entityPersister, Object[] state)`
`ModWorkUnit(SessionImplementor sessionImplementor, String entityName, AuditConfiguration verCfg, Serializable id, EntityPersister entityPersister, Object[] newState, Object[] oldState)`

Uses of EntityPersister in org.hibernate.event.internal

Methods in org.hibernate.event.internal with parameters of type EntityPersister
`protected void` `DefaultDeleteEventListener.cascadeAfterDelete(EventSource session, EntityPersister persister, Object entity, Set transientEntities)`
`protected void` `DefaultMergeEventListener.cascadeAfterSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Cascade behavior is redefined by this subclass, disable superclass behavior
`protected void` `AbstractSaveEventListener.cascadeAfterSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Handles to calls needed to perform post-save cascades.
`protected void` `DefaultDeleteEventListener.cascadeBeforeDelete(EventSource session, EntityPersister persister, Object entity, EntityEntry entityEntry, Set transientEntities)`
`protected void` `DefaultMergeEventListener.cascadeBeforeSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Cascade behavior is redefined by this subclass, disable superclass behavior
`protected void` `AbstractSaveEventListener.cascadeBeforeSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Handles the calls needed to perform pre-save cascades for the given entity.
`protected void` `DefaultMergeEventListener.cascadeOnMerge(EventSource source, EntityPersister persister, Object entity, Map copyCache)` Perform any cascades needed as part of this copy event.
`void` `DefaultFlushEntityEventListener.checkId(Object object, EntityPersister persister, Serializable id, SessionImplementor session)` make sure user didn't mangle the id
`protected void` `DefaultMergeEventListener.copyValues(EntityPersister persister, Object entity, Object target, SessionImplementor source, Map copyCache)`
`protected void` `DefaultMergeEventListener.copyValues(EntityPersister persister, Object entity, Object target, SessionImplementor source, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
`protected void` `DefaultDeleteEventListener.deleteEntity(EventSource session, Object entity, EntityEntry entityEntry, boolean isCascadeDeleteEnabled, EntityPersister persister, Set transientEntities)` Perform the entity deletion.
`protected void` `DefaultDeleteEventListener.deleteTransientEntity(EventSource session, Object entity, boolean cascadeDeleteEnabled, EntityPersister persister, Set transientEntities)` We encountered a delete request on a transient instance.
`protected void` `DefaultEvictEventListener.doEvict(Object object, EntityKey key, EntityPersister persister, EventSource session)`
`protected Object` `DefaultLoadEventListener.doLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Coordinates the efforts to load a given entity.
`protected Serializable` `DefaultSaveOrUpdateEventListener.getUpdateId(Object entity, EntityPersister persister, Serializable requestedId, SessionImplementor session)` Determine the id to use for updating.
`protected Serializable` `DefaultUpdateEventListener.getUpdateId(Object entity, EntityPersister persister, Serializable requestedId, SessionImplementor session)` If the user specified an id, assign it to the instance and use that, otherwise use the id already assigned to the instance
`protected boolean` `DefaultDeleteEventListener.invokeDeleteLifecycle(EventSource session, Object entity, EntityPersister persister)`
`protected boolean` `DefaultFlushEntityEventListener.invokeInterceptor(SessionImplementor session, Object entity, EntityEntry entry, Object[] values, EntityPersister persister)`
`protected boolean` `AbstractSaveEventListener.invokeSaveLifecycle(Object entity, EntityPersister persister, EventSource source)`
`protected boolean` `DefaultSaveOrUpdateEventListener.invokeUpdateLifecycle(Object entity, EntityPersister persister, EventSource source)`
`protected Object` `DefaultLoadEventListener.load(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Performs the load of an entity.
`protected Object` `DefaultLoadEventListener.loadFromDatasource(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Performs the process of loading an entity from the configured underlying datasource.
`protected Object` `DefaultLoadEventListener.loadFromSecondLevelCache(LoadEvent event, EntityPersister persister, LoadEventListener.LoadType options)` Attempts to load the entity from the second-level cache.
`protected Object` `DefaultLoadEventListener.lockAndLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options, SessionImplementor source)` If the class to be loaded has been configured with a cache, then lock given id in that cache and then perform the load.
`protected Serializable` `AbstractSaveEventListener.performSave(Object entity, Serializable id, EntityPersister persister, boolean useIdentityColumn, Object anything, EventSource source, boolean requiresImmediateIdAccess)` Prepares the save call by checking the session caches for a pre-existing entity and performing any lifecycle callbacks.
`protected Serializable` `AbstractSaveEventListener.performSaveOrReplicate(Object entity, EntityKey key, EntityPersister persister, boolean useIdentityColumn, Object anything, EventSource source, boolean requiresImmediateIdAccess)` Performs all the actual work needed to save an entity (well to get the save moved to the execution queue).
`protected void` `DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event, Object entity, EntityPersister persister)`
`protected Object` `DefaultLoadEventListener.proxyOrLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Based on configured options, will either return a pre-existing proxy, generate a new proxy, or perform an actual load.
`protected EntityEntry` `AbstractReassociateEventListener.reassociate(AbstractEvent event, Object object, Serializable id, EntityPersister persister)` Associates a given entity (either transient or associated with another session) to the given session.
`protected boolean` `DefaultReplicateEventListener.substituteValuesIfNecessary(Object entity, Serializable id, Object[] values, EntityPersister persister, SessionImplementor source)`
`protected boolean` `AbstractSaveEventListener.substituteValuesIfNecessary(Object entity, Serializable id, Object[] values, EntityPersister persister, SessionImplementor source)` Perform any property value substitution that is necessary (interceptor callback, version initialization...)

Uses of EntityPersister in org.hibernate.event.spi

Methods in org.hibernate.event.spi that return EntityPersister
`EntityPersister` `ResolveNaturalIdEvent.getEntityPersister()`
`EntityPersister` `AbstractPreDatabaseOperationEvent.getPersister()` The persister for the `entity`.
`EntityPersister` `PostUpdateEvent.getPersister()`
`EntityPersister` `PostDeleteEvent.getPersister()`
`EntityPersister` `PostLoadEvent.getPersister()`
`EntityPersister` `PostInsertEvent.getPersister()`
`EntityPersister` `PreLoadEvent.getPersister()`

Methods in org.hibernate.event.spi with parameters of type EntityPersister
`Object` `EventSource.instantiate(EntityPersister persister, Serializable id)` Instantiate an entity instance, using either an interceptor, or the given persister
`PostLoadEvent` `PostLoadEvent.setPersister(EntityPersister persister)`
`PreLoadEvent` `PreLoadEvent.setPersister(EntityPersister persister)`

Constructors in org.hibernate.event.spi with parameters of type EntityPersister
`AbstractPreDatabaseOperationEvent(EventSource source, Object entity, Serializable id, EntityPersister persister)` Constructs an event containing the pertinent information.
`PostDeleteEvent(Object entity, Serializable id, Object[] deletedState, EntityPersister persister, EventSource source)`
`PostInsertEvent(Object entity, Serializable id, Object[] state, EntityPersister persister, EventSource source)`
`PostUpdateEvent(Object entity, Serializable id, Object[] state, Object[] oldState, int[] dirtyProperties, EntityPersister persister, EventSource source)`
`PreDeleteEvent(Object entity, Serializable id, Object[] deletedState, EntityPersister persister, EventSource source)` Constructs an event containing the pertinent information.
`PreInsertEvent(Object entity, Serializable id, Object[] state, EntityPersister persister, EventSource source)` Constructs an event containing the pertinent information.
`PreUpdateEvent(Object entity, Serializable id, Object[] state, Object[] oldState, EntityPersister persister, EventSource source)` Constructs an event containing the pertinent information.
`ResolveNaturalIdEvent(Map<String,Object> naturalIdValues, EntityPersister entityPersister, EventSource source)`
`ResolveNaturalIdEvent(Map<String,Object> naturalIdValues, EntityPersister entityPersister, LockOptions lockOptions, EventSource source)`

Uses of EntityPersister in org.hibernate.hql.internal.ast.tree

Methods in org.hibernate.hql.internal.ast.tree that return EntityPersister
`EntityPersister` `FromElement.getEntityPersister()`

Methods in org.hibernate.hql.internal.ast.tree with parameters of type EntityPersister
`void` `FromElement.initializeEntity(FromClause fromClause, String className, EntityPersister persister, EntityType type, String classAlias, String tableAlias)`

Uses of EntityPersister in org.hibernate.hql.internal.ast.util

Methods in org.hibernate.hql.internal.ast.util that return EntityPersister
`EntityPersister` `SessionFactoryHelper.requireClassPersister(String name)` Locate the persister by class or entity name, requiring that such a persister exist.

Uses of EntityPersister in org.hibernate.id

Subinterfaces of EntityPersister in org.hibernate.id
`interface` `PostInsertIdentityPersister` A persister that may have an identity assigned by execution of a SQL `INSERT`.

Uses of EntityPersister in org.hibernate.internal

Methods in org.hibernate.internal that return EntityPersister
`EntityPersister` `SessionFactoryImpl.getEntityPersister(String entityName)`
`EntityPersister` `SessionImpl.getEntityPersister(String entityName, Object object)`
`EntityPersister` `StatelessSessionImpl.getEntityPersister(String entityName, Object object)`

Methods in org.hibernate.internal with parameters of type EntityPersister
`EntityKey` `AbstractSessionImpl.generateEntityKey(Serializable id, EntityPersister persister)`
`Object` `SessionImpl.instantiate(EntityPersister persister, Serializable id)` give the interceptor an opportunity to override the default instantiation

Uses of EntityPersister in org.hibernate.loader

Methods in org.hibernate.loader with parameters of type EntityPersister
`protected List` `Loader.loadEntity(SessionImplementor session, Object key, Object index, Type keyType, Type indexType, EntityPersister persister)` Called by subclasses that load entities
`protected List` `Loader.loadEntity(SessionImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, EntityPersister persister, LockOptions lockOptions)` Called by subclasses that load entities
`List` `Loader.loadEntityBatch(SessionImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister, LockOptions lockOptions)` Called by wrappers that batch load entities

Uses of EntityPersister in org.hibernate.loader.entity

Constructors in org.hibernate.loader.entity with parameters of type EntityPersister
`BatchingEntityLoader(EntityPersister persister, int[] batchSizes, Loader[] loaders)`

Uses of EntityPersister in org.hibernate.metamodel.binding

Methods in org.hibernate.metamodel.binding that return types with arguments of type EntityPersister
`Class<? extends EntityPersister>` `EntityBinding.getCustomEntityPersisterClass()`

Method parameters in org.hibernate.metamodel.binding with type arguments of type EntityPersister
`void` `EntityBinding.setCustomEntityPersisterClass(Class<? extends EntityPersister> customEntityPersisterClass)`

Uses of EntityPersister in org.hibernate.persister.collection

Methods in org.hibernate.persister.collection that return EntityPersister
`EntityPersister` `QueryableCollection.getElementPersister()` Get the persister of the element class, if this is a collection of entities (optional operation).
`EntityPersister` `AbstractCollectionPersister.getElementPersister()`
`EntityPersister` `CollectionPersister.getOwnerEntityPersister()` Get the persister of the entity that "owns" this collection
`EntityPersister` `AbstractCollectionPersister.getOwnerEntityPersister()`

Uses of EntityPersister in org.hibernate.persister.entity

Subinterfaces of EntityPersister in org.hibernate.persister.entity
`interface` `Loadable` Implemented by a `EntityPersister` that may be loaded using `Loader`.
`interface` `Lockable` Contract for things that can be locked via a `LockingStrategy`.
`interface` `OuterJoinLoadable` A `EntityPersister` that may be loaded by outer join using the `OuterJoinLoader` hierarchy and may be an element of a one-to-many association.
`interface` `Queryable` Extends the generic `EntityPersister` contract to add operations required by the Hibernate Query Language
`interface` `SQLLoadable` A class persister that supports queries expressed in the platform native SQL dialect
`interface` `UniqueKeyLoadable`

Classes in org.hibernate.persister.entity that implement EntityPersister
`class` `AbstractEntityPersister` Basic functionality for persisting an entity via JDBC through either generated or custom SQL
`class` `JoinedSubclassEntityPersister` An `EntityPersister` implementing the normalized "table-per-subclass" mapping strategy
`class` `SingleTableEntityPersister` The default implementation of the `EntityPersister` interface.
`class` `UnionSubclassEntityPersister` Implementation of the "table-per-concrete-class" or "roll-down" mapping strategy for an entity and its inheritence hierarchy.

Methods in org.hibernate.persister.entity that return EntityPersister
`EntityPersister` `AbstractEntityPersister.getSubclassEntityPersister(Object instance, SessionFactoryImplementor factory)`
`EntityPersister` `EntityPersister.getSubclassEntityPersister(Object instance, SessionFactoryImplementor factory)` A request has already identified the entity-name of this persister as the mapping for the given instance.

Constructors in org.hibernate.persister.entity with parameters of type EntityPersister
`NamedQueryLoader(String queryName, EntityPersister persister)`

Uses of EntityPersister in org.hibernate.persister.internal

Methods in org.hibernate.persister.internal that return EntityPersister
`EntityPersister` `PersisterFactoryImpl.createEntityPersister(EntityBinding metadata, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)`
`EntityPersister` `PersisterFactoryImpl.createEntityPersister(PersistentClass metadata, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)`

Methods in org.hibernate.persister.internal that return types with arguments of type EntityPersister
`Class<? extends EntityPersister>` `StandardPersisterClassResolver.getEntityPersisterClass(EntityBinding metadata)`
`Class<? extends EntityPersister>` `StandardPersisterClassResolver.getEntityPersisterClass(PersistentClass metadata)`
`Class<? extends EntityPersister>` `StandardPersisterClassResolver.joinedSubclassEntityPersister()`
`Class<? extends EntityPersister>` `StandardPersisterClassResolver.singleTableEntityPersister()`
`Class<? extends EntityPersister>` `StandardPersisterClassResolver.unionSubclassEntityPersister()`

Uses of EntityPersister in org.hibernate.persister.spi

Methods in org.hibernate.persister.spi that return EntityPersister
`EntityPersister` `PersisterFactory.createEntityPersister(EntityBinding model, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)` Create an entity persister instance.
`EntityPersister` `PersisterFactory.createEntityPersister(PersistentClass model, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)` Create an entity persister instance.

Methods in org.hibernate.persister.spi that return types with arguments of type EntityPersister
`Class<? extends EntityPersister>` `PersisterClassResolver.getEntityPersisterClass(EntityBinding metadata)` Returns the entity persister class for a given entityName or null if the entity persister class should be the default.
`Class<? extends EntityPersister>` `PersisterClassResolver.getEntityPersisterClass(PersistentClass metadata)` Returns the entity persister class for a given entityName or null if the entity persister class should be the default.

Uses of EntityPersister in org.hibernate.pretty

Methods in org.hibernate.pretty with parameters of type EntityPersister
`static String` `MessageHelper.infoString(EntityPersister persister)` Generate an info message string relating to given entity persister.
`static String` `MessageHelper.infoString(EntityPersister persister, Object id, SessionFactoryImplementor factory)` Generate an info message string relating to a particular entity.
`static String` `MessageHelper.infoString(EntityPersister persister, Object id, Type identifierType, SessionFactoryImplementor factory)` Generate an info message string relating to a particular entity,.
`static String` `MessageHelper.infoString(EntityPersister persister, Serializable[] ids, SessionFactoryImplementor factory)` Generate an info message string relating to a series of entities.

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.