## org.hibernate.engine.spi
Class EntityEntry

    java.lang.Object
      org.hibernate.engine.spi.EntityEntry

All Implemented Interfaces:
  Serializable

    public final class EntityEntry

extends Object
implements Serializable

We need an entry to tell us all about the current state of an object with respect to its persistent state

See Also:
  Serialized Form

Constructor Summary
`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)`

Method Summary
`static EntityEntry` `deserialize(ObjectInputStream ois, PersistenceContext persistenceContext)` Custom deserialization routine used during deserialization of a Session/PersistenceContext for increased performance.
`void` `forceLocked(Object entity, Object nextVersion)`
`Object[]` `getDeletedState()`
`EntityKey` `getEntityKey()` Get the EntityKey based on this EntityEntry.
`String` `getEntityName()`
`Serializable` `getId()`
`Object[]` `getLoadedState()`
`Object` `getLoadedValue(String propertyName)`
`LockMode` `getLockMode()`
`EntityPersister` `getPersister()`
`Object` `getRowId()`
`Status` `getStatus()`
`Object` `getVersion()`
`boolean` `isBeingReplicated()`
`boolean` `isExistsInDatabase()`
`boolean` `isLoadedWithLazyPropertiesUnfetched()`
`boolean` `isModifiableEntity()` Can the entity be modified? The entity is modifiable if all of the following are true: the entity class is mutable the entity is not read-only if the current status is Status.DELETED, then the entity was not read-only when it was deleted
`boolean` `isNullifiable(boolean earlyInsert, SessionImplementor session)`
`boolean` `isReadOnly()`
`void` `postDelete()` After actually deleting a row, record the fact that the instance no longer exists in the database
`void` `postInsert(Object[] insertedState)` After actually inserting a row, record the fact that the instance exists on the database (needed for identity-column key generation)
`void` `postUpdate(Object entity, Object[] updatedState, Object nextVersion)` Handle updating the internal state of the entry after actually performing the database update.
`boolean` `requiresDirtyCheck(Object entity)` Not sure this is the best method name, but the general idea here is to return `true` if the entity can possibly be dirty.
`void` `serialize(ObjectOutputStream oos)` Custom serialization routine used during serialization of a Session/PersistenceContext for increased performance.
`void` `setDeletedState(Object[] deletedState)`
`void` `setLockMode(LockMode lockMode)`
`void` `setReadOnly(boolean readOnly, Object entity)`
`void` `setStatus(Status status)`
`String` `toString()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### EntityEntry

    public 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)

Method Detail

### getLockMode

    public LockMode getLockMode()

### setLockMode

    public void setLockMode(LockMode lockMode)

### getStatus

    public Status getStatus()

### setStatus

    public void setStatus(Status status)

### getId

    public Serializable getId()

### getLoadedState

    public Object[] getLoadedState()

### getDeletedState

    public Object[] getDeletedState()

### setDeletedState

    public void setDeletedState(Object[] deletedState)

### isExistsInDatabase

    public boolean isExistsInDatabase()

### getVersion

    public Object getVersion()

### getPersister

    public EntityPersister getPersister()

### getEntityKey

    public EntityKey getEntityKey()

  Get the EntityKey based on this EntityEntry.

  Returns:
    the EntityKey
  Throws:
    `IllegalStateException` - if getId() is null

### getEntityName

    public String getEntityName()

### isBeingReplicated

    public boolean isBeingReplicated()

### getRowId

    public Object getRowId()

### postUpdate

    public void postUpdate(Object entity,
                           Object[] updatedState,
                           Object nextVersion)

  Handle updating the internal state of the entry after actually performing the database update. Specifically we update the snapshot information and escalate the lock mode

  Parameters:
    `entity` - The entity instance
    `updatedState` - The state calculated after the update (becomes the new `loaded state`.
    `nextVersion` - The new version.

### postDelete

    public void postDelete()

  After actually deleting a row, record the fact that the instance no longer exists in the database

### postInsert

    public void postInsert(Object[] insertedState)

  After actually inserting a row, record the fact that the instance exists on the database (needed for identity-column key generation)

### isNullifiable

    public boolean isNullifiable(boolean earlyInsert,
                                 SessionImplementor session)

### getLoadedValue

    public Object getLoadedValue(String propertyName)

### requiresDirtyCheck

    public boolean requiresDirtyCheck(Object entity)

  Not sure this is the best method name, but the general idea here is to return `true` if the entity can possibly be dirty. This can only be the case if it is in a modifiable state (not read-only/deleted) and it either has mutable properties or field-interception is not telling us it is dirty. Clear as mud? :/ A name like canPossiblyBeDirty might be better

  Parameters:
    `entity` - The entity to test
  Returns:
    `true` indicates that the entity could possibly be dirty and that dirty check should happen; `false` indicates there is no way the entity can be dirty

### isModifiableEntity

    public boolean isModifiableEntity()

  Can the entity be modified? The entity is modifiable if all of the following are true:
  - the entity class is mutable
  - the entity is not read-only
  - if the current status is Status.DELETED, then the entity was not read-only when it was deleted

  Returns:
    true, if the entity is modifiable; false, otherwise,

### forceLocked

    public void forceLocked(Object entity,
                            Object nextVersion)

### isReadOnly

    public boolean isReadOnly()

### setReadOnly

    public void setReadOnly(boolean readOnly,
                            Object entity)

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### isLoadedWithLazyPropertiesUnfetched

    public boolean isLoadedWithLazyPropertiesUnfetched()

### serialize

    public void serialize(ObjectOutputStream oos)
                   throws IOException

  Custom serialization routine used during serialization of a Session/PersistenceContext for increased performance.

  Parameters:
    `oos` - The stream to which we should write the serial data.
  Throws:
    `IOException` - If a stream error occurs

### deserialize

    public static EntityEntry deserialize(ObjectInputStream ois,
                                          PersistenceContext persistenceContext)
                                   throws IOException,
                                          ClassNotFoundException

  Custom deserialization routine used during deserialization of a Session/PersistenceContext for increased performance.

  Parameters:
    `ois` - The stream from which to read the entry.
    `persistenceContext` - The context being deserialized.
  Returns:
    The deserialized EntityEntry
  Throws:
    `IOException` - If a stream error occurs
    `ClassNotFoundException` - If any of the classes declared in the stream cannot be found

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