How to use org.hibernate.engine.internal

  @Override
  public void handleEviction(Object object, EntityPersister persister, Serializable identifier) {
    naturalIdXrefDelegate.removeNaturalIdCrossReference(
        persister,
        identifier,
        findCachedNaturalId( persister, identifier )
    );
  }
};

  @Override
  public void afterTransactionCompletion() {
    cleanUpInsertedKeysAfterTransaction();
    entityEntryContext.downgradeLocks();
//        // Downgrade locks
//        for ( EntityEntry o : entityEntries.values() ) {
//            o.setLockMode( LockMode.NONE );
//        }
  }

@Override
public Object[] getDeletedState() {
  final EntityEntryExtraStateHolder extra = getExtraState( EntityEntryExtraStateHolder.class );
  return extra != null ? extra.getDeletedState() : DEFAULT_DELETED_STATE;
}

@Override
public void setDeletedState(Object[] deletedState) {
  EntityEntryExtraStateHolder extra = getExtraState( EntityEntryExtraStateHolder.class );
  if ( extra == null && deletedState == DEFAULT_DELETED_STATE ) {
    //this is the default value and we do not store the extra state
    return;
  }
  if ( extra == null ) {
    extra = new EntityEntryExtraStateHolder();
    addExtraState( extra );
  }
  extra.setDeletedState( deletedState );
}

private boolean isSubclassAliasDereferenced(Join join, String withClauseFragment) {
  if ( join.getJoinable() instanceof AbstractEntityPersister ) {
    AbstractEntityPersister persister = (AbstractEntityPersister) join.getJoinable();
    int subclassTableSpan = persister.getSubclassTableSpan();
    for ( int j = 1; j < subclassTableSpan; j++ ) {
      String subclassAlias = AbstractEntityPersister.generateTableAlias( join.getAlias(), j );
      if ( isAliasDereferenced( withClauseFragment, subclassAlias ) ) {
        return true;
      }
    }
  }
  return false;
}

@Override
public void postDelete() {
  setCompressedValue( EnumState.PREVIOUS_STATUS, getStatus() );
  setCompressedValue( EnumState.STATUS, Status.GONE );
  setCompressedValue( BooleanState.EXISTS_IN_DATABASE, false );
}

/**
 * Access to the session (via the PersistenceContext) to which this delegate ultimately belongs.
 *
 * @return The session
 */
protected SharedSessionContractImplementor session() {
  return persistenceContext.getSession();
}

/**
 * clear all the internal collections, just
 * to help the garbage collector, does not
 * clear anything that is needed during the
 * afterTransactionCompletion() phase
 */
@Override
protected void cleanupOnClose() {
  persistenceContext.clear();
}

/**
 * Nullify all references to entities that have not yet been inserted in the database, where the foreign key
 * points toward that entity.
 *
 * @param values The entity attribute values
 * @param types The entity attribute types
 */
public void nullifyTransientReferences(final Object[] values, final Type[] types) {
  for ( int i = 0; i < types.length; i++ ) {
    values[i] = nullifyTransientReferences( values[i], types[i] );
  }
}

@Override
public void addNewCollection(CollectionPersister persister, PersistentCollection collection)
    throws HibernateException {
  addCollection( collection, persister );
}

@Override
public boolean requiresDirtyCheck(Object entity) {
  return isModifiableEntity()
      && ( !isUnequivocallyNonDirty( entity ) );
}

@Override
public boolean isDefaultReadOnly() {
  return persistenceContext.isDefaultReadOnly();
}

/**
 * Generate a JoinFragment
 *
 * @return The JoinFragment
 *
 * @throws MappingException Indicates a problem access the provided metadata, or incorrect metadata
 */
public JoinFragment toJoinFragment() throws MappingException {
  return toJoinFragment( Collections.EMPTY_MAP, true );
}

/**
 * Generate an empty join sequence instance.
 *
 * @return The generate join sequence.
 */
public JoinSequence createJoinSequence() {
  return new JoinSequence( sfi );
}

/**
 * Does this entity exist in this context, associated with an EntityEntry?
 *
 * @param entity The entity to check
 *
 * @return {@code true} if it is associated with this context
 */
public boolean hasEntityEntry(Object entity) {
  return getEntityEntry( entity ) != null;
}

@Override
public int getNumberOfManagedEntities() {
  return entityEntryContext.getNumberOfManagedEntities();
}

@Override
public Collection<Serializable> getCachedPkResolutions(EntityPersister entityPersister) {
  return naturalIdXrefDelegate.getCachedPkResolutions( entityPersister );
}

@Override
public Status getStatus() {
  return getCompressedValue( EnumState.STATUS );
}

@Override
public EntityEntry getValue() {
  return getEntityEntry();
}

@Override
public void setStatus(Status status) {
  if ( status == Status.READ_ONLY ) {
    //memory optimization
    loadedState = null;
  }
  final Status currentStatus = this.getStatus();
  if ( currentStatus != status ) {
    setCompressedValue( EnumState.PREVIOUS_STATUS, currentStatus );
    setCompressedValue( EnumState.STATUS, status );
  }
}