org.hibernate.LockMode

Here are the examples of the java api org.hibernate.LockMode taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

195 Examples 7

19 Source : EntityCriteria.java
with MIT License
from theonedev

public EnreplacedyCriteria<T> setLockMode(String alias, LockMode lockMode) {
    criteria.setLockMode(alias, lockMode);
    return this;
}

19 Source : EntityCriteria.java
with MIT License
from theonedev

public EnreplacedyCriteria<T> setLockMode(LockMode lockMode) {
    criteria.setLockMode(lockMode);
    return this;
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        emr.session.lock(enreplacedyName, object, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public void lock(Object object, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        emr.session.lock(object, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        return emr.session.load(theClreplaced, id, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        return emr.session.get(enreplacedyName, id, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public void refresh(Object object, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        emr.session.refresh(object, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public <T> T get(Clreplaced<T> enreplacedyType, Serializable id, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        return emr.session.get(enreplacedyType, id, lockMode);
    }
}

19 Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio

@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
    checkBlocking();
    try (SessionResult emr = acquireSession()) {
        return emr.session.load(enreplacedyName, id, lockMode);
    }
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
    return delegate().load(theClreplaced, id, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
    return delegate().get(enreplacedyName, id, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
    delegate().lock(enreplacedyName, object, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public <T> T get(Clreplaced<T> enreplacedyType, Serializable id, LockMode lockMode) {
    return delegate().get(enreplacedyType, id, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public void lock(Object object, LockMode lockMode) {
    delegate().lock(object, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public void refresh(Object object, LockMode lockMode) {
    delegate().refresh(object, lockMode);
}

19 Source : ForwardingSession.java
with Apache License 2.0
from quarkusio

@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
    return delegate().load(enreplacedyName, id, lockMode);
}

19 Source : CheckIDUtil.java
with GNU Lesser General Public License v2.1
from phoenixctms

public static Object checkEnreplacedyId(String enreplacedyName, Long id, Object dao, LockMode lockMode) throws Exception {
    return replacedociationPath.findMethod(CHECK_ENreplacedY_ID_METHOD_PREFIX + enreplacedyName + CHECK_ENreplacedY_ID_METHOD_SUFFIX, LOCK_MODE_METHOD_TRANSFILTER, false, CheckIDUtil.clreplaced.getMethods()).invoke(null, id, dao, lockMode);
}

19 Source : CheckIDUtil.java
with GNU Lesser General Public License v2.1
from phoenixctms

public static ECRF checkEcrfId(Long ecrfId, ECRFDao ecrfDao, LockMode lockMode) throws ServiceException {
    ECRF ecrf = ecrfDao.load(ecrfId, lockMode);
    if (ecrf == null) {
        throw L10nUtil.initServiceException(ServiceExceptionCodes.INVALID_ECRF_ID, ecrfId == null ? null : ecrfId.toString());
    }
    return ecrf;
}

19 Source : SimpleSelect.java
with GNU General Public License v2.0
from lamsfoundation

public SimpleSelect setLockMode(LockMode lockMode) {
    this.lockOptions.setLockMode(lockMode);
    return this;
}

19 Source : ForUpdateFragment.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * @author Gavin King
 */
public clreplaced ForUpdateFragment {

    private final StringBuilder aliases = new StringBuilder();

    private boolean isNowaitEnabled;

    private boolean isSkipLockedEnabled;

    private final Dialect dialect;

    private LockMode lockMode;

    private LockOptions lockOptions;

    public ForUpdateFragment(Dialect dialect) {
        this.dialect = dialect;
    }

    public ForUpdateFragment(Dialect dialect, LockOptions lockOptions, Map<String, String[]> keyColumnNames) throws QueryException {
        this(dialect);
        LockMode upgradeType = null;
        Iterator iter = lockOptions.getAliasLockIterator();
        this.lockOptions = lockOptions;
        if (!iter.hasNext()) {
            // no tables referenced
            final LockMode lockMode = lockOptions.getLockMode();
            if (LockMode.READ.lessThan(lockMode)) {
                upgradeType = lockMode;
                this.lockMode = lockMode;
            }
        }
        while (iter.hasNext()) {
            final Map.Entry me = (Map.Entry) iter.next();
            final LockMode lockMode = (LockMode) me.getValue();
            if (LockMode.READ.lessThan(lockMode)) {
                final String tableAlias = (String) me.getKey();
                if (dialect.forUpdateOfColumns()) {
                    // use the id column alias
                    String[] keyColumns = keyColumnNames.get(tableAlias);
                    if (keyColumns == null) {
                        throw new IllegalArgumentException("alias not found: " + tableAlias);
                    }
                    keyColumns = StringHelper.qualify(tableAlias, keyColumns);
                    for (String keyColumn : keyColumns) {
                        addTableAlias(keyColumn);
                    }
                } else {
                    addTableAlias(tableAlias);
                }
                if (upgradeType != null && lockMode != upgradeType) {
                    throw new QueryException("mixed LockModes");
                }
                upgradeType = lockMode;
            }
        }
        if (upgradeType == LockMode.UPGRADE_NOWAIT || lockOptions.getTimeOut() == LockOptions.NO_WAIT) {
            setNowaitEnabled(true);
        }
        if (upgradeType == LockMode.UPGRADE_SKIPLOCKED || lockOptions.getTimeOut() == LockOptions.SKIP_LOCKED) {
            setSkipLockedEnabled(true);
        }
    }

    public ForUpdateFragment addTableAlias(String alias) {
        if (aliases.length() > 0) {
            aliases.append(", ");
        }
        aliases.append(alias);
        return this;
    }

    public String toFragmentString() {
        if (lockOptions != null) {
            if (aliases.length() == 0) {
                return dialect.getForUpdateString(lockOptions);
            } else {
                return dialect.getForUpdateString(aliases.toString(), lockOptions);
            }
        } else if (aliases.length() == 0) {
            if (lockMode != null) {
                return dialect.getForUpdateString(lockMode);
            }
            return "";
        }
        // TODO:  preplaced lockmode
        if (isNowaitEnabled) {
            return dialect.getForUpdateNowaitString(aliases.toString());
        } else if (isSkipLockedEnabled) {
            return dialect.getForUpdateSkipLockedString(aliases.toString());
        } else {
            return dialect.getForUpdateString(aliases.toString());
        }
    }

    public ForUpdateFragment setNowaitEnabled(boolean nowait) {
        isNowaitEnabled = nowait;
        return this;
    }

    public ForUpdateFragment setSkipLockedEnabled(boolean skipLocked) {
        isSkipLockedEnabled = skipLocked;
        return this;
    }
}

19 Source : NativeQueryReturnBuilderRootImpl.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * @author Steve Ebersole
 */
public clreplaced NativeQueryReturnBuilderRootImpl implements NativeQuery.RootReturn, NativeQueryReturnBuilder {

    private final String alias;

    private final String enreplacedyName;

    private LockMode lockMode = LockMode.READ;

    private Map<String, String[]> propertyMappings;

    public NativeQueryReturnBuilderRootImpl(String alias, String enreplacedyName) {
        this.alias = alias;
        this.enreplacedyName = enreplacedyName;
    }

    public NativeQuery.RootReturn setLockMode(LockMode lockMode) {
        this.lockMode = lockMode;
        return this;
    }

    public NativeQuery.RootReturn setDiscriminatorAlias(String alias) {
        addProperty("clreplaced", alias);
        return this;
    }

    public NativeQuery.RootReturn addProperty(String propertyName, String columnAlias) {
        addProperty(propertyName).addColumnAlias(columnAlias);
        return this;
    }

    public NativeQuery.ReturnProperty addProperty(final String propertyName) {
        if (propertyMappings == null) {
            propertyMappings = new HashMap<>();
        }
        return new NativeQuery.ReturnProperty() {

            public NativeQuery.ReturnProperty addColumnAlias(String columnAlias) {
                String[] columnAliases = propertyMappings.get(propertyName);
                if (columnAliases == null) {
                    columnAliases = new String[] { columnAlias };
                } else {
                    String[] newColumnAliases = new String[columnAliases.length + 1];
                    System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
                    newColumnAliases[columnAliases.length] = columnAlias;
                    columnAliases = newColumnAliases;
                }
                propertyMappings.put(propertyName, columnAliases);
                return this;
            }
        };
    }

    public NativeSQLQueryReturn buildReturn() {
        return new NativeSQLQueryRootReturn(alias, enreplacedyName, propertyMappings, lockMode);
    }
}

19 Source : NativeQueryReturnBuilderRootImpl.java
with GNU General Public License v2.0
from lamsfoundation

public NativeQuery.RootReturn setLockMode(LockMode lockMode) {
    this.lockMode = lockMode;
    return this;
}

19 Source : NativeQueryReturnBuilderFetchImpl.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * @author Steve Ebersole
 */
public clreplaced NativeQueryReturnBuilderFetchImpl implements NativeQuery.FetchReturn, NativeQueryReturnBuilder {

    private final String alias;

    private String ownerTableAlias;

    private final String joinedPropertyName;

    private LockMode lockMode = LockMode.READ;

    private Map<String, String[]> propertyMappings;

    public NativeQueryReturnBuilderFetchImpl(String alias, String ownerTableAlias, String joinedPropertyName) {
        this.alias = alias;
        this.ownerTableAlias = ownerTableAlias;
        this.joinedPropertyName = joinedPropertyName;
    }

    public NativeQuery.FetchReturn setLockMode(LockMode lockMode) {
        this.lockMode = lockMode;
        return this;
    }

    public NativeQuery.FetchReturn addProperty(String propertyName, String columnAlias) {
        addProperty(propertyName).addColumnAlias(columnAlias);
        return this;
    }

    public NativeQuery.ReturnProperty addProperty(final String propertyName) {
        if (propertyMappings == null) {
            propertyMappings = new HashMap<>();
        }
        return new NativeQuery.ReturnProperty() {

            public NativeQuery.ReturnProperty addColumnAlias(String columnAlias) {
                String[] columnAliases = propertyMappings.get(propertyName);
                if (columnAliases == null) {
                    columnAliases = new String[] { columnAlias };
                } else {
                    String[] newColumnAliases = new String[columnAliases.length + 1];
                    System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
                    newColumnAliases[columnAliases.length] = columnAlias;
                    columnAliases = newColumnAliases;
                }
                propertyMappings.put(propertyName, columnAliases);
                return this;
            }
        };
    }

    public NativeSQLQueryReturn buildReturn() {
        return new NativeSQLQueryJoinReturn(alias, ownerTableAlias, joinedPropertyName, propertyMappings, lockMode);
    }
}

19 Source : NativeQueryReturnBuilderFetchImpl.java
with GNU General Public License v2.0
from lamsfoundation

public NativeQuery.FetchReturn setLockMode(LockMode lockMode) {
    this.lockMode = lockMode;
    return this;
}

19 Source : SelectStatementBuilder.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Sets the lock mode for the select statement.
 *
 * @param lockMode The lock mode.
 */
public void setLockMode(LockMode lockMode) {
    this.lockOptions.setLockMode(lockMode);
}

19 Source : NonScalarReturn.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Represents some non-scalar (enreplacedy/collection) return within the query result.
 *
 * @author Steve Ebersole
 */
public abstract clreplaced NonScalarReturn implements Return {

    private final String alias;

    private final LockMode lockMode;

    public NonScalarReturn(String alias, LockMode lockMode) {
        this.alias = alias;
        if (alias == null) {
            throw new HibernateException("alias must be specified");
        }
        this.lockMode = lockMode;
    }

    public String getAlias() {
        return alias;
    }

    public LockMode getLockMode() {
        return lockMode;
    }
}

19 Source : LockModeTypeHelper.java
with GNU General Public License v2.0
from lamsfoundation

public static LockMode interpretLockMode(Object value) {
    if (value == null) {
        return LockMode.NONE;
    }
    if (LockMode.clreplaced.isInstance(value)) {
        return (LockMode) value;
    } else if (LockModeType.clreplaced.isInstance(value)) {
        return getLockMode((LockModeType) value);
    } else if (String.clreplaced.isInstance(value)) {
        // first try LockMode name
        LockMode lockMode = LockMode.valueOf((String) value);
        if (lockMode == null) {
            try {
                lockMode = getLockMode(LockModeType.valueOf((String) value));
            } catch (Exception ignore) {
            }
        }
        if (lockMode != null) {
            return lockMode;
        }
    }
    throw new IllegalArgumentException("Unknown lock mode source : " + value);
}

19 Source : ArrayHelper.java
with GNU General Public License v2.0
from lamsfoundation

public static LockMode[] fillArray(LockMode lockMode, int length) {
    LockMode[] array = new LockMode[length];
    Arrays.fill(array, lockMode);
    return array;
}

19 Source : StatelessSessionImpl.java
with GNU General Public License v2.0
from lamsfoundation

private LockMode getNullSafeLockMode(LockMode lockMode) {
    return lockMode == null ? LockMode.NONE : lockMode;
}

19 Source : CriteriaImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public Criteria setLockMode(String alias, LockMode lockMode) {
    lockModes.put(alias, lockMode);
    return this;
}

19 Source : CriteriaImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public Criteria setLockMode(LockMode lockMode) {
    return setLockMode(getAlias(), lockMode);
}

19 Source : ResolveNaturalIdEvent.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Defines an event clreplaced for the resolving of an enreplacedy id from the enreplacedy's natural-id
 *
 * @author Eric Dalquist
 * @author Steve Ebersole
 */
public clreplaced ResolveNaturalIdEvent extends AbstractEvent {

    public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;

    private final EnreplacedyPersister enreplacedyPersister;

    private final Map<String, Object> naturalIdValues;

    private final Object[] orderedNaturalIdValues;

    private final LockOptions lockOptions;

    private Serializable enreplacedyId;

    public ResolveNaturalIdEvent(Map<String, Object> naturalIdValues, EnreplacedyPersister enreplacedyPersister, EventSource source) {
        this(naturalIdValues, enreplacedyPersister, new LockOptions(), source);
    }

    public ResolveNaturalIdEvent(Map<String, Object> naturalIdValues, EnreplacedyPersister enreplacedyPersister, LockOptions lockOptions, EventSource source) {
        super(source);
        if (enreplacedyPersister == null) {
            throw new IllegalArgumentException("EnreplacedyPersister is required for loading");
        }
        if (!enreplacedyPersister.hasNaturalIdentifier()) {
            throw new HibernateException("Enreplacedy did not define a natural-id");
        }
        if (naturalIdValues == null || naturalIdValues.isEmpty()) {
            throw new IllegalArgumentException("natural-id to load is required");
        }
        if (enreplacedyPersister.getNaturalIdentifierProperties().length != naturalIdValues.size()) {
            throw new HibernateException(String.format("Enreplacedy [%s] defines its natural-id with %d properties but only %d were specified", enreplacedyPersister.getEnreplacedyName(), enreplacedyPersister.getNaturalIdentifierProperties().length, naturalIdValues.size()));
        }
        if (lockOptions.getLockMode() == LockMode.WRITE) {
            throw new IllegalArgumentException("Invalid lock mode for loading");
        } else if (lockOptions.getLockMode() == null) {
            lockOptions.setLockMode(DEFAULT_LOCK_MODE);
        }
        this.enreplacedyPersister = enreplacedyPersister;
        this.naturalIdValues = naturalIdValues;
        this.lockOptions = lockOptions;
        int[] naturalIdPropertyPositions = enreplacedyPersister.getNaturalIdentifierProperties();
        orderedNaturalIdValues = new Object[naturalIdPropertyPositions.length];
        int i = 0;
        for (int position : naturalIdPropertyPositions) {
            final String propertyName = enreplacedyPersister.getPropertyNames()[position];
            if (!naturalIdValues.containsKey(propertyName)) {
                throw new HibernateException(String.format("No value specified for natural-id property %s#%s", getEnreplacedyName(), propertyName));
            }
            orderedNaturalIdValues[i++] = naturalIdValues.get(enreplacedyPersister.getPropertyNames()[position]);
        }
    }

    public Map<String, Object> getNaturalIdValues() {
        return Collections.unmodifiableMap(naturalIdValues);
    }

    public Object[] getOrderedNaturalIdValues() {
        return orderedNaturalIdValues;
    }

    public EnreplacedyPersister getEnreplacedyPersister() {
        return enreplacedyPersister;
    }

    public String getEnreplacedyName() {
        return getEnreplacedyPersister().getEnreplacedyName();
    }

    public LockOptions getLockOptions() {
        return lockOptions;
    }

    public Serializable getEnreplacedyId() {
        return enreplacedyId;
    }

    public void setEnreplacedyId(Serializable enreplacedyId) {
        this.enreplacedyId = enreplacedyId;
    }
}

19 Source : LockEvent.java
with GNU General Public License v2.0
from lamsfoundation

public void setLockMode(LockMode lockMode) {
    this.lockOptions.setLockMode(lockMode);
}

19 Source : LoadEvent.java
with GNU General Public License v2.0
from lamsfoundation

/**
 *  Defines an event clreplaced for the loading of an enreplacedy.
 *
 * @author Steve Ebersole
 */
public clreplaced LoadEvent extends AbstractEvent {

    public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;

    // Performance hotspot: avoid allocating unneeded LockOptions
    public static final LockOptions DEFAULT_LOCK_OPTIONS = new LockOptions() {

        @Override
        public LockOptions setLockMode(LockMode lockMode) {
            throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
        }

        @Override
        public LockOptions setAlireplacedpecificLockMode(String alias, LockMode lockMode) {
            throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
        }

        @Override
        public LockOptions setTimeOut(int timeout) {
            throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
        }

        @Override
        public LockOptions setScope(boolean scope) {
            throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
        }
    };

    private Serializable enreplacedyId;

    private String enreplacedyClreplacedName;

    private Object instanceToLoad;

    private LockOptions lockOptions;

    private boolean isreplacedociationFetch;

    private Object result;

    private PostLoadEvent postLoadEvent;

    public LoadEvent(Serializable enreplacedyId, Object instanceToLoad, EventSource source) {
        this(enreplacedyId, null, instanceToLoad, DEFAULT_LOCK_OPTIONS, false, source);
    }

    public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, LockMode lockMode, EventSource source) {
        this(enreplacedyId, enreplacedyClreplacedName, null, lockMode, false, source);
    }

    public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, LockOptions lockOptions, EventSource source) {
        this(enreplacedyId, enreplacedyClreplacedName, null, lockOptions, false, source);
    }

    public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, boolean isreplacedociationFetch, EventSource source) {
        this(enreplacedyId, enreplacedyClreplacedName, null, DEFAULT_LOCK_OPTIONS, isreplacedociationFetch, source);
    }

    public boolean isreplacedociationFetch() {
        return isreplacedociationFetch;
    }

    private LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, Object instanceToLoad, LockMode lockMode, boolean isreplacedociationFetch, EventSource source) {
        this(enreplacedyId, enreplacedyClreplacedName, instanceToLoad, lockMode == DEFAULT_LOCK_MODE ? DEFAULT_LOCK_OPTIONS : new LockOptions().setLockMode(lockMode), isreplacedociationFetch, source);
    }

    private LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, Object instanceToLoad, LockOptions lockOptions, boolean isreplacedociationFetch, EventSource source) {
        super(source);
        if (enreplacedyId == null) {
            throw new IllegalArgumentException("id to load is required for loading");
        }
        if (lockOptions.getLockMode() == LockMode.WRITE) {
            throw new IllegalArgumentException("Invalid lock mode for loading");
        } else if (lockOptions.getLockMode() == null) {
            lockOptions.setLockMode(DEFAULT_LOCK_MODE);
        }
        this.enreplacedyId = enreplacedyId;
        this.enreplacedyClreplacedName = enreplacedyClreplacedName;
        this.instanceToLoad = instanceToLoad;
        this.lockOptions = lockOptions;
        this.isreplacedociationFetch = isreplacedociationFetch;
        this.postLoadEvent = new PostLoadEvent(source);
    }

    public Serializable getEnreplacedyId() {
        return enreplacedyId;
    }

    public void setEnreplacedyId(Serializable enreplacedyId) {
        this.enreplacedyId = enreplacedyId;
    }

    public String getEnreplacedyClreplacedName() {
        return enreplacedyClreplacedName;
    }

    public void setEnreplacedyClreplacedName(String enreplacedyClreplacedName) {
        this.enreplacedyClreplacedName = enreplacedyClreplacedName;
    }

    public Object getInstanceToLoad() {
        return instanceToLoad;
    }

    public void setInstanceToLoad(Object instanceToLoad) {
        this.instanceToLoad = instanceToLoad;
    }

    public LockOptions getLockOptions() {
        return lockOptions;
    }

    public LockMode getLockMode() {
        return lockOptions.getLockMode();
    }

    public void setLockMode(LockMode lockMode) {
        if (lockMode != lockOptions.getLockMode()) {
            writingOnLockOptions();
            this.lockOptions.setLockMode(lockMode);
        }
    }

    private void writingOnLockOptions() {
        if (lockOptions == DEFAULT_LOCK_OPTIONS) {
            this.lockOptions = new LockOptions();
        }
    }

    public void setLockTimeout(int timeout) {
        if (timeout != lockOptions.getTimeOut()) {
            writingOnLockOptions();
            this.lockOptions.setTimeOut(timeout);
        }
    }

    public int getLockTimeout() {
        return this.lockOptions.getTimeOut();
    }

    public void setLockScope(boolean cascade) {
        if (lockOptions.getScope() != cascade) {
            writingOnLockOptions();
            this.lockOptions.setScope(cascade);
        }
    }

    public boolean getLockScope() {
        return this.lockOptions.getScope();
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

    public PostLoadEvent getPostLoadEvent() {
        return postLoadEvent;
    }

    public void setPostLoadEvent(PostLoadEvent postLoadEvent) {
        this.postLoadEvent = postLoadEvent;
    }
}

19 Source : LoadEvent.java
with GNU General Public License v2.0
from lamsfoundation

public void setLockMode(LockMode lockMode) {
    if (lockMode != lockOptions.getLockMode()) {
        writingOnLockOptions();
        this.lockOptions.setLockMode(lockMode);
    }
}

19 Source : DefaultPostLoadEventListener.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public void onPostLoad(PostLoadEvent event) {
    final Object enreplacedy = event.getEnreplacedy();
    callbackRegistry.postLoad(enreplacedy);
    final EnreplacedyEntry entry = event.getSession().getPersistenceContext().getEntry(enreplacedy);
    if (entry == null) {
        throw new replacedertionFailure("possible non-threadsafe access to the session");
    }
    final LockMode lockMode = entry.getLockMode();
    if (LockMode.PESSIMISTIC_FORCE_INCREMENT.equals(lockMode)) {
        final EnreplacedyPersister persister = entry.getPersister();
        final Object nextVersion = persister.forceVersionIncrement(entry.getId(), entry.getVersion(), event.getSession());
        entry.forceLocked(enreplacedy, nextVersion);
    } else if (LockMode.OPTIMISTIC_FORCE_INCREMENT.equals(lockMode)) {
        final EnreplacedyIncrementVersionProcess incrementVersion = new EnreplacedyIncrementVersionProcess(enreplacedy, entry);
        event.getSession().getActionQueue().registerProcess(incrementVersion);
    } else if (LockMode.OPTIMISTIC.equals(lockMode)) {
        final EnreplacedyVerifyVersionProcess verifyVersion = new EnreplacedyVerifyVersionProcess(enreplacedy, entry);
        event.getSession().getActionQueue().registerProcess(verifyVersion);
    }
    if (event.getPersister().implementsLifecycle()) {
        // log.debug( "calling onLoad()" );
        ((Lifecycle) event.getEnreplacedy()).onLoad(event.getSession(), event.getId());
    }
}

19 Source : DefaultLoadEventListener.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Defines the default load event listeners used by hibernate for loading enreplacedies
 * in response to generated load events.
 *
 * @author Steve Ebersole
 */
public clreplaced DefaultLoadEventListener extends AbstractLockUpgradeEventListener implements LoadEventListener {

    public static final Object REMOVED_ENreplacedY_MARKER = new Object();

    public static final Object INCONSISTENT_RTN_CLreplaced_MARKER = new Object();

    public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;

    private static final CoreMessageLogger LOG = CoreLogging.messageLogger(DefaultLoadEventListener.clreplaced);

    private static final boolean traceEnabled = LOG.isTraceEnabled();

    /**
     * Handle the given load event.
     *
     * @param event The load event to be handled.
     *
     * @throws HibernateException
     */
    public void onLoad(final LoadEvent event, final LoadEventListener.LoadType loadType) throws HibernateException {
        final EnreplacedyPersister persister = getPersister(event);
        if (persister == null) {
            throw new HibernateException("Unable to locate persister: " + event.getEnreplacedyClreplacedName());
        }
        final Clreplaced idClreplaced = persister.getIdentifierType().getReturnedClreplaced();
        if (idClreplaced != null && !idClreplaced.isInstance(event.getEnreplacedyId()) && !DelayedPostInsertIdentifier.clreplaced.isInstance(event.getEnreplacedyId())) {
            checkIdClreplaced(persister, event, loadType, idClreplaced);
        }
        doOnLoad(persister, event, loadType);
    }

    protected EnreplacedyPersister getPersister(final LoadEvent event) {
        if (event.getInstanceToLoad() != null) {
            // the load() which takes an enreplacedy does not preplaced an enreplacedyName
            event.setEnreplacedyClreplacedName(event.getInstanceToLoad().getClreplaced().getName());
            return event.getSession().getEnreplacedyPersister(null, event.getInstanceToLoad());
        } else {
            return event.getSession().getFactory().getEnreplacedyPersister(event.getEnreplacedyClreplacedName());
        }
    }

    private void doOnLoad(final EnreplacedyPersister persister, final LoadEvent event, final LoadEventListener.LoadType loadType) {
        try {
            final EnreplacedyKey keyToLoad = event.getSession().generateEnreplacedyKey(event.getEnreplacedyId(), persister);
            if (loadType.isNakedEnreplacedyReturned()) {
                // do not return a proxy!
                // (this option indicates we are initializing a proxy)
                event.setResult(load(event, persister, keyToLoad, loadType));
            } else {
                // return a proxy if appropriate
                if (event.getLockMode() == LockMode.NONE) {
                    event.setResult(proxyOrLoad(event, persister, keyToLoad, loadType));
                } else {
                    event.setResult(lockAndLoad(event, persister, keyToLoad, loadType, event.getSession()));
                }
            }
        } catch (HibernateException e) {
            LOG.unableToLoadCommand(e);
            throw e;
        }
    }

    private void checkIdClreplaced(final EnreplacedyPersister persister, final LoadEvent event, final LoadEventListener.LoadType loadType, final Clreplaced idClreplaced) {
        // we may have the kooky jpa requirement of allowing find-by-id where
        // "id" is the "simple pk value" of a dependent objects parent.  This
        // is part of its generally goofy "derived idenreplacedy" "feature"
        if (persister.getEnreplacedyMetamodel().getIdentifierProperty().isEmbedded()) {
            final EmbeddedComponentType dependentIdType = (EmbeddedComponentType) persister.getEnreplacedyMetamodel().getIdentifierProperty().getType();
            if (dependentIdType.getSubtypes().length == 1) {
                final Type singleSubType = dependentIdType.getSubtypes()[0];
                if (singleSubType.isEnreplacedyType()) {
                    final EnreplacedyType dependentParentType = (EnreplacedyType) singleSubType;
                    final Type dependentParentIdType = dependentParentType.getIdentifierOrUniqueKeyType(event.getSession().getFactory());
                    if (dependentParentIdType.getReturnedClreplaced().isInstance(event.getEnreplacedyId())) {
                        // yep that's what we have...
                        loadByDerivedIdenreplacedySimplePkValue(event, loadType, persister, dependentIdType, event.getSession().getFactory().getEnreplacedyPersister(dependentParentType.getreplacedociatedEnreplacedyName()));
                        return;
                    }
                }
            }
        }
        throw new TypeMismatchException("Provided id of the wrong type for clreplaced " + persister.getEnreplacedyName() + ". Expected: " + idClreplaced + ", got " + event.getEnreplacedyId().getClreplaced());
    }

    private void loadByDerivedIdenreplacedySimplePkValue(LoadEvent event, LoadEventListener.LoadType options, EnreplacedyPersister dependentPersister, EmbeddedComponentType dependentIdType, EnreplacedyPersister parentPersister) {
        final EnreplacedyKey parentEnreplacedyKey = event.getSession().generateEnreplacedyKey(event.getEnreplacedyId(), parentPersister);
        final Object parent = doLoad(event, parentPersister, parentEnreplacedyKey, options);
        final Serializable dependent = (Serializable) dependentIdType.instantiate(parent, event.getSession());
        dependentIdType.setPropertyValues(dependent, new Object[] { parent }, dependentPersister.getEnreplacedyMode());
        final EnreplacedyKey dependentEnreplacedyKey = event.getSession().generateEnreplacedyKey(dependent, dependentPersister);
        event.setEnreplacedyId(dependent);
        event.setResult(doLoad(event, dependentPersister, dependentEnreplacedyKey, options));
    }

    /**
     * Performs the load of an enreplacedy.
     *
     * @param event The initiating load request event
     * @param persister The persister corresponding to the enreplacedy to be loaded
     * @param keyToLoad The key of the enreplacedy to be loaded
     * @param options The defined load options
     *
     * @return The loaded enreplacedy.
     *
     * @throws HibernateException
     */
    private Object load(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
        if (event.getInstanceToLoad() != null) {
            if (event.getSession().getPersistenceContext().getEntry(event.getInstanceToLoad()) != null) {
                throw new PersistentObjectException("attempted to load into an instance that was already replacedociated with the session: " + MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
            }
            persister.setIdentifier(event.getInstanceToLoad(), event.getEnreplacedyId(), event.getSession());
        }
        final Object enreplacedy = doLoad(event, persister, keyToLoad, options);
        boolean isOptionalInstance = event.getInstanceToLoad() != null;
        if (enreplacedy == null && (!options.isAllowNulls() || isOptionalInstance)) {
            event.getSession().getFactory().getEnreplacedyNotFoundDelegate().handleEnreplacedyNotFound(event.getEnreplacedyClreplacedName(), event.getEnreplacedyId());
        } else if (isOptionalInstance && enreplacedy != event.getInstanceToLoad()) {
            throw new NonUniqueObjectException(event.getEnreplacedyId(), event.getEnreplacedyClreplacedName());
        }
        return enreplacedy;
    }

    /**
     * Based on configured options, will either return a pre-existing proxy,
     * generate a new proxy, or perform an actual load.
     *
     * @param event The initiating load request event
     * @param persister The persister corresponding to the enreplacedy to be loaded
     * @param keyToLoad The key of the enreplacedy to be loaded
     * @param options The defined load options
     *
     * @return The result of the proxy/load operation.
     */
    private Object proxyOrLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
        if (traceEnabled) {
            LOG.tracev("Loading enreplacedy: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
        }
        // this clreplaced has no proxies (so do a shortcut)
        if (!persister.hasProxy()) {
            return load(event, persister, keyToLoad, options);
        }
        final PersistenceContext persistenceContext = event.getSession().getPersistenceContext();
        // look for a proxy
        Object proxy = persistenceContext.getProxy(keyToLoad);
        if (proxy != null) {
            return returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy);
        }
        if (options.isAllowProxyCreation()) {
            return createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext);
        }
        // return a newly loaded object
        return load(event, persister, keyToLoad, options);
    }

    /**
     * Given a proxy, initialize it and/or narrow it provided either
     * is necessary.
     *
     * @param event The initiating load request event
     * @param persister The persister corresponding to the enreplacedy to be loaded
     * @param keyToLoad The key of the enreplacedy to be loaded
     * @param options The defined load options
     * @param persistenceContext The originating session
     * @param proxy The proxy to narrow
     *
     * @return The created/existing proxy
     */
    private Object returnNarrowedProxy(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext, final Object proxy) {
        if (traceEnabled) {
            LOG.trace("Enreplacedy proxy found in session cache");
        }
        LazyInitializer li = ((HibernateProxy) proxy).getHibernateLazyInitializer();
        if (li.isUnwrap()) {
            return li.getImplementation();
        }
        Object impl = null;
        if (!options.isAllowProxyCreation()) {
            impl = load(event, persister, keyToLoad, options);
            if (impl == null) {
                event.getSession().getFactory().getEnreplacedyNotFoundDelegate().handleEnreplacedyNotFound(persister.getEnreplacedyName(), keyToLoad.getIdentifier());
            }
        }
        return persistenceContext.narrowProxy(proxy, persister, keyToLoad, impl);
    }

    /**
     * If there is already a corresponding proxy replacedociated with the
     * persistence context, return it; otherwise create a proxy, replacedociate it
     * with the persistence context, and return the just-created proxy.
     *
     * @param event The initiating load request event
     * @param persister The persister corresponding to the enreplacedy to be loaded
     * @param keyToLoad The key of the enreplacedy to be loaded
     * @param options The defined load options
     * @param persistenceContext The originating session
     *
     * @return The created/existing proxy
     */
    private Object createProxyIfNecessary(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext) {
        Object existing = persistenceContext.getEnreplacedy(keyToLoad);
        if (existing != null) {
            // return existing object or initialized proxy (unless deleted)
            if (traceEnabled) {
                LOG.trace("Enreplacedy found in session cache");
            }
            if (options.isCheckDeleted()) {
                EnreplacedyEntry entry = persistenceContext.getEntry(existing);
                Status status = entry.getStatus();
                if (status == Status.DELETED || status == Status.GONE) {
                    return null;
                }
            }
            return existing;
        }
        if (traceEnabled) {
            LOG.trace("Creating new proxy for enreplacedy");
        }
        // return new uninitialized proxy
        Object proxy = persister.createProxy(event.getEnreplacedyId(), event.getSession());
        persistenceContext.getBatchFetchQueue().addBatchLoadableEnreplacedyKey(keyToLoad);
        persistenceContext.addProxy(keyToLoad, proxy);
        return proxy;
    }

    /**
     * If the clreplaced to be loaded has been configured with a cache, then lock
     * given id in that cache and then perform the load.
     *
     * @param event The initiating load request event
     * @param persister The persister corresponding to the enreplacedy to be loaded
     * @param keyToLoad The key of the enreplacedy to be loaded
     * @param options The defined load options
     * @param source The originating session
     *
     * @return The loaded enreplacedy
     *
     * @throws HibernateException
     */
    private Object lockAndLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final SessionImplementor source) {
        SoftLock lock = null;
        final Object ck;
        final EnreplacedyDataAccess cache = persister.getCacheAccessStrategy();
        if (persister.canWriteToCache()) {
            ck = cache.generateCacheKey(event.getEnreplacedyId(), persister, source.getFactory(), source.getTenantIdentifier());
            lock = persister.getCacheAccessStrategy().lockItem(source, ck, null);
        } else {
            ck = null;
        }
        Object enreplacedy;
        try {
            enreplacedy = load(event, persister, keyToLoad, options);
        } finally {
            if (persister.canWriteToCache()) {
                cache.unlockItem(source, ck, lock);
            }
        }
        return event.getSession().getPersistenceContext().proxyFor(persister, keyToLoad, enreplacedy);
    }

    /**
     * Coordinates the efforts to load a given enreplacedy.  First, an attempt is
     * made to load the enreplacedy from the session-level cache.  If not found there,
     * an attempt is made to locate it in second-level cache.  Lastly, an
     * attempt is made to load it directly from the datasource.
     *
     * @param event The load event
     * @param persister The persister for the enreplacedy being requested for load
     * @param keyToLoad The EnreplacedyKey representing the enreplacedy to be loaded.
     * @param options The load options.
     *
     * @return The loaded enreplacedy, or null.
     */
    private Object doLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
        if (traceEnabled) {
            LOG.tracev("Attempting to resolve: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
        }
        Object enreplacedy = loadFromSessionCache(event, keyToLoad, options);
        if (enreplacedy == REMOVED_ENreplacedY_MARKER) {
            LOG.debug("Load request found matching enreplacedy in context, but it is scheduled for removal; returning null");
            return null;
        }
        if (enreplacedy == INCONSISTENT_RTN_CLreplaced_MARKER) {
            LOG.debug("Load request found matching enreplacedy in context, but the matched enreplacedy was of an inconsistent return type; returning null");
            return null;
        }
        if (enreplacedy != null) {
            if (traceEnabled) {
                LOG.tracev("Resolved object in session cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
            }
            return enreplacedy;
        }
        enreplacedy = loadFromSecondLevelCache(event, persister, keyToLoad);
        if (enreplacedy != null) {
            if (traceEnabled) {
                LOG.tracev("Resolved object in second-level cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
            }
        } else {
            if (traceEnabled) {
                LOG.tracev("Object not resolved in any cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
            }
            enreplacedy = loadFromDatasource(event, persister);
        }
        if (enreplacedy != null && persister.hasNaturalIdentifier()) {
            event.getSession().getPersistenceContext().getNaturalIdHelper().cacheNaturalIdCrossReferenceFromLoad(persister, event.getEnreplacedyId(), event.getSession().getPersistenceContext().getNaturalIdHelper().extractNaturalIdValues(enreplacedy, persister));
        }
        return enreplacedy;
    }

    /**
     * Performs the process of loading an enreplacedy from the configured
     * underlying datasource.
     *
     * @param event The load event
     * @param persister The persister for the enreplacedy being requested for load
     *
     * @return The object loaded from the datasource, or null if not found.
     */
    protected Object loadFromDatasource(final LoadEvent event, final EnreplacedyPersister persister) {
        Object enreplacedy = persister.load(event.getEnreplacedyId(), event.getInstanceToLoad(), event.getLockOptions(), event.getSession());
        if (event.isreplacedociationFetch() && event.getSession().getFactory().getStatistics().isStatisticsEnabled()) {
            event.getSession().getFactory().getStatistics().fetchEnreplacedy(event.getEnreplacedyClreplacedName());
        }
        return enreplacedy;
    }

    /**
     * Attempts to locate the enreplacedy in the session-level cache.
     * <p/>
     * If allowed to return nulls, then if the enreplacedy happens to be found in
     * the session cache, we check the enreplacedy type for proper handling
     * of enreplacedy hierarchies.
     * <p/>
     * If checkDeleted was set to true, then if the enreplacedy is found in the
     * session-level cache, it's current status within the session cache
     * is checked to see if it has previously been scheduled for deletion.
     *
     * @param event The load event
     * @param keyToLoad The EnreplacedyKey representing the enreplacedy to be loaded.
     * @param options The load options.
     *
     * @return The enreplacedy from the session-level cache, or null.
     *
     * @throws HibernateException Generally indicates problems applying a lock-mode.
     */
    protected Object loadFromSessionCache(final LoadEvent event, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) throws HibernateException {
        SessionImplementor session = event.getSession();
        Object old = session.getEnreplacedyUsingInterceptor(keyToLoad);
        if (old != null) {
            // this object was already loaded
            EnreplacedyEntry oldEntry = session.getPersistenceContext().getEntry(old);
            if (options.isCheckDeleted()) {
                Status status = oldEntry.getStatus();
                if (status == Status.DELETED || status == Status.GONE) {
                    return REMOVED_ENreplacedY_MARKER;
                }
            }
            if (options.isAllowNulls()) {
                final EnreplacedyPersister persister = event.getSession().getFactory().getEnreplacedyPersister(keyToLoad.getEnreplacedyName());
                if (!persister.isInstance(old)) {
                    return INCONSISTENT_RTN_CLreplaced_MARKER;
                }
            }
            upgradeLock(old, oldEntry, event.getLockOptions(), event.getSession());
        }
        return old;
    }

    /**
     * Attempts to load the enreplacedy from the second-level cache.
     *
     * @param event The load event
     * @param persister The persister for the enreplacedy being requested for load
     *
     * @return The enreplacedy from the second-level cache, or null.
     */
    private Object loadFromSecondLevelCache(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey enreplacedyKey) {
        final SessionImplementor source = event.getSession();
        final boolean useCache = persister.canReadFromCache() && source.getCacheMode().isGetEnabled() && event.getLockMode().lessThan(LockMode.READ);
        if (!useCache) {
            // we can't use cache here
            return null;
        }
        final Object ce = getFromSharedCache(event, persister, source);
        if (ce == null) {
            // nothing was found in cache
            return null;
        }
        return processCachedEntry(event, persister, ce, source, enreplacedyKey);
    }

    private Object processCachedEntry(final LoadEvent event, final EnreplacedyPersister persister, final Object ce, final SessionImplementor source, final EnreplacedyKey enreplacedyKey) {
        CacheEntry entry = (CacheEntry) persister.getCacheEntryStructure().destructure(ce, source.getFactory());
        if (entry.isReferenceEntry()) {
            if (event.getInstanceToLoad() != null) {
                throw new HibernateException("Attempt to load enreplacedy [%s] from cache using provided object instance, but cache " + "is storing references: " + event.getEnreplacedyId());
            } else {
                return convertCacheReferenceEntryToEnreplacedy((ReferenceCacheEntryImpl) entry, event.getSession(), enreplacedyKey);
            }
        } else {
            Object enreplacedy = convertCacheEntryToEnreplacedy(entry, event.getEnreplacedyId(), persister, event, enreplacedyKey);
            if (!persister.isInstance(enreplacedy)) {
                throw new WrongClreplacedException("loaded object was of wrong clreplaced " + enreplacedy.getClreplaced(), event.getEnreplacedyId(), persister.getEnreplacedyName());
            }
            return enreplacedy;
        }
    }

    private Object getFromSharedCache(final LoadEvent event, final EnreplacedyPersister persister, SessionImplementor source) {
        final EnreplacedyDataAccess cache = persister.getCacheAccessStrategy();
        final Object ck = cache.generateCacheKey(event.getEnreplacedyId(), persister, source.getFactory(), source.getTenantIdentifier());
        final Object ce = CacheHelper.fromSharedCache(source, ck, persister.getCacheAccessStrategy());
        if (source.getFactory().getStatistics().isStatisticsEnabled()) {
            if (ce == null) {
                source.getFactory().getStatistics().enreplacedyCacheMiss(StatsHelper.INSTANCE.getRootEnreplacedyRole(persister), cache.getRegion().getName());
            } else {
                source.getFactory().getStatistics().enreplacedyCacheHit(StatsHelper.INSTANCE.getRootEnreplacedyRole(persister), cache.getRegion().getName());
            }
        }
        return ce;
    }

    private Object convertCacheReferenceEntryToEnreplacedy(ReferenceCacheEntryImpl referenceCacheEntry, EventSource session, EnreplacedyKey enreplacedyKey) {
        final Object enreplacedy = referenceCacheEntry.getReference();
        if (enreplacedy == null) {
            throw new IllegalStateException("Reference cache entry contained null : " + referenceCacheEntry.toString());
        } else {
            makeEnreplacedyCircularReferenceSafe(referenceCacheEntry, session, enreplacedy, enreplacedyKey);
            return enreplacedy;
        }
    }

    private void makeEnreplacedyCircularReferenceSafe(ReferenceCacheEntryImpl referenceCacheEntry, EventSource session, Object enreplacedy, EnreplacedyKey enreplacedyKey) {
        // make it circular-reference safe
        final StatefulPersistenceContext statefulPersistenceContext = (StatefulPersistenceContext) session.getPersistenceContext();
        if ((enreplacedy instanceof ManagedEnreplacedy)) {
            statefulPersistenceContext.addReferenceEntry(enreplacedy, Status.READ_ONLY);
        } else {
            TwoPhaseLoad.addUninitializedCachedEnreplacedy(enreplacedyKey, enreplacedy, referenceCacheEntry.getSubclreplacedPersister(), LockMode.NONE, referenceCacheEntry.getVersion(), session);
        }
        statefulPersistenceContext.initializeNonLazyCollections();
    }

    private Object convertCacheEntryToEnreplacedy(CacheEntry entry, Serializable enreplacedyId, EnreplacedyPersister persister, LoadEvent event, EnreplacedyKey enreplacedyKey) {
        final EventSource session = event.getSession();
        final SessionFactoryImplementor factory = session.getFactory();
        final EnreplacedyPersister subclreplacedPersister;
        if (traceEnabled) {
            LOG.tracef("Converting second-level cache entry [%s] into enreplacedy : %s", entry, MessageHelper.infoString(persister, enreplacedyId, factory));
        }
        final Object enreplacedy;
        subclreplacedPersister = factory.getEnreplacedyPersister(entry.getSubclreplaced());
        final Object optionalObject = event.getInstanceToLoad();
        enreplacedy = optionalObject == null ? session.instantiate(subclreplacedPersister, enreplacedyId) : optionalObject;
        // make it circular-reference safe
        TwoPhaseLoad.addUninitializedCachedEnreplacedy(enreplacedyKey, enreplacedy, subclreplacedPersister, LockMode.NONE, entry.getVersion(), session);
        final PersistenceContext persistenceContext = session.getPersistenceContext();
        final Object[] values;
        final Object version;
        final boolean isReadOnly;
        final Type[] types = subclreplacedPersister.getPropertyTypes();
        // initializes the enreplacedy by (desired) side-effect
        values = ((StandardCacheEntryImpl) entry).replacedemble(enreplacedy, enreplacedyId, subclreplacedPersister, session.getInterceptor(), session);
        if (((StandardCacheEntryImpl) entry).isDeepCopyNeeded()) {
            TypeHelper.deepCopy(values, types, subclreplacedPersister.getPropertyUpdateability(), values, session);
        }
        version = Versioning.getVersion(values, subclreplacedPersister);
        LOG.tracef("Cached Version : %s", version);
        final Object proxy = persistenceContext.getProxy(enreplacedyKey);
        if (proxy != null) {
            // there is already a proxy for this impl
            // only set the status to read-only if the proxy is read-only
            isReadOnly = ((HibernateProxy) proxy).getHibernateLazyInitializer().isReadOnly();
        } else {
            isReadOnly = session.isDefaultReadOnly();
        }
        persistenceContext.addEntry(enreplacedy, (isReadOnly ? Status.READ_ONLY : Status.MANAGED), values, null, enreplacedyId, version, LockMode.NONE, true, subclreplacedPersister, false);
        subclreplacedPersister.afterInitialize(enreplacedy, session);
        persistenceContext.initializeNonLazyCollections();
        // PostLoad is needed for EJB3
        PostLoadEvent postLoadEvent = event.getPostLoadEvent().setEnreplacedy(enreplacedy).setId(enreplacedyId).setPersister(persister);
        for (PostLoadEventListener listener : postLoadEventListeners(session)) {
            listener.onPostLoad(postLoadEvent);
        }
        return enreplacedy;
    }

    private Iterable<PostLoadEventListener> postLoadEventListeners(EventSource session) {
        return session.getFactory().getServiceRegistry().getService(EventListenerRegistry.clreplaced).getEventListenerGroup(EventType.POST_LOAD).listeners();
    }
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public <T> T get(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
    return delegate.get(theClreplaced, id, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
    return delegate.load(theClreplaced, id, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
    return delegate.get(enreplacedyName, id, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
    delegate.lock(enreplacedyName, object, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public void lock(Object object, LockMode lockMode) {
    delegate.lock(object, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public void refresh(Object object, LockMode lockMode) {
    delegate.refresh(object, lockMode);
}

19 Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
    return delegate.load(enreplacedyName, id, lockMode);
}

19 Source : NativeSQLQueryNonScalarReturn.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Represents the base information for a non-scalar return defined as part of
 * a native sql query.
 *
 * @author Steve Ebersole
 */
public abstract clreplaced NativeSQLQueryNonScalarReturn implements NativeSQLQueryReturn, Serializable {

    private final String alias;

    private final LockMode lockMode;

    private final Map<String, String[]> propertyResults = new HashMap<String, String[]>();

    private final int hashCode;

    /**
     * Constructs some form of non-scalar return descriptor
     *
     * @param alias The result alias
     * @param propertyResults Any user-supplied column->property mappings
     * @param lockMode The lock mode to apply to the return.
     */
    protected NativeSQLQueryNonScalarReturn(String alias, Map<String, String[]> propertyResults, LockMode lockMode) {
        this.alias = alias;
        if (alias == null) {
            throw new HibernateException("alias must be specified");
        }
        this.lockMode = lockMode;
        if (propertyResults != null) {
            this.propertyResults.putAll(propertyResults);
        }
        this.hashCode = determineHashCode();
    }

    private int determineHashCode() {
        int result = alias != null ? alias.hashCode() : 0;
        result = 31 * result + (getClreplaced().getName().hashCode());
        result = 31 * result + (lockMode != null ? lockMode.hashCode() : 0);
        result = 31 * result + propertyResults.hashCode();
        return result;
    }

    /**
     * Retrieve the defined result alias
     *
     * @return The result alias.
     */
    public String getAlias() {
        return alias;
    }

    /**
     * Retrieve the lock-mode to apply to this return
     *
     * @return The lock mode
     */
    public LockMode getLockMode() {
        return lockMode;
    }

    /**
     * Retrieve the user-supplied column->property mappings.
     *
     * @return The property mappings.
     */
    public Map<String, String[]> getPropertyResultsMap() {
        return Collections.unmodifiableMap(propertyResults);
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    @SuppressWarnings("RedundantIfStatement")
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClreplaced() != o.getClreplaced()) {
            return false;
        }
        final NativeSQLQueryNonScalarReturn that = (NativeSQLQueryNonScalarReturn) o;
        if (alias != null ? !alias.equals(that.alias) : that.alias != null) {
            return false;
        }
        if (lockMode != null ? !lockMode.equals(that.lockMode) : that.lockMode != null) {
            return false;
        }
        if (!propertyResults.equals(that.propertyResults)) {
            return false;
        }
        return true;
    }

    @Override
    public void traceLog(TraceLogger logger) {
        if (NativeSQLQueryRootReturn.clreplaced.isInstance(this)) {
            logger.writeLine("Enreplacedy(...)");
        } else if (NativeSQLQueryCollectionReturn.clreplaced.isInstance(this)) {
            logger.writeLine("Collection(...)");
        } else if (NativeSQLQueryJoinReturn.clreplaced.isInstance(this)) {
            logger.writeLine("Join(...)");
        } else {
            logger.writeLine(getClreplaced().getName() + "(...)");
        }
    }
}

19 Source : MutableEntityEntryFactory.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public EnreplacedyEntry createEnreplacedyEntry(Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EnreplacedyPersister persister, boolean disableVersionIncrement, PersistenceContext persistenceContext) {
    return new MutableEnreplacedyEntry(status, loadedState, rowId, id, version, lockMode, existsInDatabase, persister, disableVersionIncrement, persistenceContext);
}

19 Source : ImmutableEntityEntryFactory.java
with GNU General Public License v2.0
from lamsfoundation

@Override
public EnreplacedyEntry createEnreplacedyEntry(Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EnreplacedyPersister persister, boolean disableVersionIncrement, PersistenceContext persistenceContext) {
    return new ImmutableEnreplacedyEntry(status, loadedState, rowId, id, version, lockMode, existsInDatabase, persister, disableVersionIncrement, persistenceContext);
}

19 Source : DetachedCriteria.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Set an alias-specific lock mode.  The specified lock mode applies only to that alias.
 *
 * @param alias The alias to apply the lock to
 * @param lockMode The lock mode to use.
 *
 * @return {@code this}, for method chaining
 */
public DetachedCriteria setLockMode(String alias, LockMode lockMode) {
    criteria.setLockMode(alias, lockMode);
    return this;
}

19 Source : DetachedCriteria.java
with GNU General Public License v2.0
from lamsfoundation

/**
 * Set the lock mode to use.
 *
 * @param lockMode The lock mode to use
 *
 * @return {@code this}, for method chaining
 */
public DetachedCriteria setLockMode(LockMode lockMode) {
    criteria.setLockMode(lockMode);
    return this;
}

19 Source : LockModeConverter.java
with GNU General Public License v2.0
from lamsfoundation

public static String toXml(LockMode lockMode) {
    return lockMode.toExternalForm();
}

See More Examples