org.hibernate.persister.entity.EntityPersister - java examples

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

155 Examples 7

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Generates an appropriate EnreplacedyEntry instance and adds it
 * to the event source's internal caches.
 */
public EnreplacedyEntry addEntry(final Object enreplacedy, final Status status, final Object[] loadedState, final Object rowId, final Serializable id, final Object version, final LockMode lockMode, final boolean existsInDatabase, final EnreplacedyPersister persister, final boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched) {
    EnreplacedyEntry e = new EnreplacedyEntry(status, loadedState, rowId, id, version, lockMode, existsInDatabase, persister, session.getEnreplacedyMode(), disableVersionIncrement, lazyPropertiesAreUnfetched);
    enreplacedyEntries.put(enreplacedy, e);
    setHasNonReadOnlyEnties(status);
    return e;
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private Object[] getDatabaseSnapshot(SessionImplementor session, EnreplacedyPersister persister, Serializable id) {
    if (persister.isSelectBeforeUpdateRequired()) {
        Object[] snapshot = session.getPersistenceContext().getDatabaseSnapshot(id, persister);
        if (snapshot == null) {
            // do we even really need this? the update will fail anyway....
            if (session.getFactory().getStatistics().isStatisticsEnabled()) {
                session.getFactory().getStatisticsImplementor().optimisticFailure(persister.getEnreplacedyName());
            }
            throw new StaleObjectStateException(persister.getEnreplacedyName(), id);
        } else {
            return snapshot;
        }
    } else {
        // TODO: optimize away this lookup for enreplacedies w/o unsaved-value="undefined"
        EnreplacedyKey enreplacedyKey = new EnreplacedyKey(id, persister, session.getEnreplacedyMode());
        return session.getPersistenceContext().getCachedDatabaseSnapshot(enreplacedyKey);
    }
}

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Return the existing proxy replacedociated with the given <tt>EnreplacedyKey</tt>, or the
 * argument (the enreplacedy replacedociated with the key) if no proxy exists.
 * (slower than the form above)
 */
public Object proxyFor(Object impl) throws HibernateException {
    EnreplacedyEntry e = getEntry(impl);
    EnreplacedyPersister p = e.getPersister();
    return proxyFor(p, new EnreplacedyKey(e.getId(), p, session.getEnreplacedyMode()), impl);
}

19 View Complete Implementation : EntityType.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * {@inheritDoc}
 */
public boolean isEqual(Object x, Object y, EnreplacedyMode enreplacedyMode, SessionFactoryImplementor factory) {
    EnreplacedyPersister persister = factory.getEnreplacedyPersister(replacedociatedEnreplacedyName);
    if (!persister.canExtractIdOutOfEnreplacedy()) {
        return super.isEqual(x, y, enreplacedyMode);
    }
    Serializable xid;
    if (x instanceof HibernateProxy) {
        xid = ((HibernateProxy) x).getHibernateLazyInitializer().getIdentifier();
    } else {
        xid = persister.getIdentifier(x, enreplacedyMode);
    }
    Serializable yid;
    if (y instanceof HibernateProxy) {
        yid = ((HibernateProxy) y).getHibernateLazyInitializer().getIdentifier();
    } else {
        yid = persister.getIdentifier(y, enreplacedyMode);
    }
    return persister.getIdentifierType().isEqual(xid, yid, enreplacedyMode, factory);
}

19 View Complete Implementation : DotNode.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Is the given property name a reference to the primary key of the replacedociated
 * enreplacedy construed by the given enreplacedy type?
 * <p/>
 * For example, consider a fragment like order.customer.id
 * (where order is a from-element alias).  Here, we'd have:
 * propertyName = "id" AND
 * owningType = ManyToOneType(Customer)
 * and are being asked to determine whether "customer.id" is a reference
 * to customer's PK...
 *
 * @param propertyName The name of the property to check.
 * @param owningType The type represeting the enreplacedy "owning" the property
 * @return True if propertyName references the enreplacedy's (owningType->replacedociatedEnreplacedy)
 * primary key; false otherwise.
 */
private boolean isReferenceToPrimaryKey(String propertyName, EnreplacedyType owningType) {
    EnreplacedyPersister persister = getSessionFactoryHelper().getFactory().getEnreplacedyPersister(owningType.getreplacedociatedEnreplacedyName());
    if (persister.getEnreplacedyMetamodel().hasNonIdentifierPropertyNamedId()) {
        // only the identifier property field name can be a reference to the replacedociated enreplacedy's PK...
        return propertyName.equals(persister.getIdentifierPropertyName()) && owningType.isReferenceToPrimaryKey();
    } else {
        // here, we have two possibilities:
        // 1) the property-name matches the explicitly identifier property name
        // 2) the property-name matches the implicit 'id' property name
        if (EnreplacedyPersister.ENreplacedY_ID.equals(propertyName)) {
            // the referenced node text is the special 'id'
            return owningType.isReferenceToPrimaryKey();
        } else {
            String keyPropertyName = getSessionFactoryHelper().getIdentifierOrUniqueKeyPropertyName(owningType);
            return keyPropertyName != null && keyPropertyName.equals(propertyName) && owningType.isReferenceToPrimaryKey();
        }
    }
}

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Return the existing proxy replacedociated with the given <tt>EnreplacedyKey</tt>, or the
 * third argument (the enreplacedy replacedociated with the key) if no proxy exists. Init
 * the proxy to the target implementation, if necessary.
 */
public Object proxyFor(EnreplacedyPersister persister, EnreplacedyKey key, Object impl) throws HibernateException {
    if (!persister.hasProxy())
        return impl;
    Object proxy = proxiesByKey.get(key);
    if (proxy != null) {
        return narrowProxy(proxy, persister, key, impl);
    } else {
        return impl;
    }
}

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy
 * and overwrite the registration of the old one. This breaks == and occurs only for
 * "clreplaced" proxies rather than "interface" proxies. Also init the proxy to point to
 * the given target implementation if necessary.
 *
 * @param proxy The proxy instance to be narrowed.
 * @param persister The persister for the proxied enreplacedy.
 * @param key The internal cache key for the proxied enreplacedy.
 * @param object (optional) the actual proxied enreplacedy instance.
 * @return An appropriately narrowed instance.
 * @throws HibernateException
 */
public Object narrowProxy(Object proxy, EnreplacedyPersister persister, EnreplacedyKey key, Object object) throws HibernateException {
    boolean alreadyNarrow = persister.getConcreteProxyClreplaced(session.getEnreplacedyMode()).isreplacedignableFrom(proxy.getClreplaced());
    if (!alreadyNarrow) {
        if (PROXY_WARN_LOG.isWarnEnabled()) {
            PROXY_WARN_LOG.warn("Narrowing proxy to " + persister.getConcreteProxyClreplaced(session.getEnreplacedyMode()) + " - this operation breaks ==");
        }
        if (object != null) {
            proxiesByKey.remove(key);
            // return the proxied object
            return object;
        } else {
            proxy = persister.createProxy(key.getIdentifier(), session);
            // overwrite old proxy
            proxiesByKey.put(key, proxy);
            return proxy;
        }
    } else {
        if (object != null) {
            LazyInitializer li = ((HibernateProxy) proxy).getHibernateLazyInitializer();
            li.setImplementation(object);
        }
        return proxy;
    }
}

19 View Complete Implementation : EntityType.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Get the identifier value of an instance or proxy.
 * <p/>
 * Intended only for loggin purposes!!!
 *
 * @param object The object from which to extract the identifier.
 * @param persister The enreplacedy persister
 * @param enreplacedyMode The enreplacedy mode
 * @return The extracted identifier.
 */
private static Serializable getIdentifier(Object object, EnreplacedyPersister persister, EnreplacedyMode enreplacedyMode) {
    if (object instanceof HibernateProxy) {
        HibernateProxy proxy = (HibernateProxy) object;
        LazyInitializer li = proxy.getHibernateLazyInitializer();
        return li.getIdentifier();
    } else {
        return persister.getIdentifier(object, enreplacedyMode);
    }
}

19 View Complete Implementation : DefaultDeleteEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected void cascadeAfterDelete(EventSource session, EnreplacedyPersister persister, Object enreplacedy, Set transientEnreplacedies) throws HibernateException {
    CacheMode cacheMode = session.getCacheMode();
    session.setCacheMode(CacheMode.GET);
    session.getPersistenceContext().incrementCascadeLevel();
    try {
        // cascade-delete to many-to-one AFTER the parent was deleted
        new Cascade(CascadingAction.DELETE, Cascade.BEFORE_INSERT_AFTER_DELETE, session).cascade(persister, enreplacedy, transientEnreplacedies);
    } finally {
        session.getPersistenceContext().decrementCascadeLevel();
        session.setCacheMode(cacheMode);
    }
}

19 View Complete Implementation : DefaultMergeEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private boolean isVersionChanged(Object enreplacedy, EventSource source, EnreplacedyPersister persister, Object target) {
    if (!persister.isVersioned()) {
        return false;
    }
    // for merging of versioned enreplacedies, we consider the version having
    // been changed only when:
    // 1) the two version values are different;
    // *AND*
    // 2) The target actually represents database state!
    // 
    // This second condition is a special case which allows
    // an enreplacedy to be merged during the same transaction
    // (though during a seperate operation) in which it was
    // originally persisted/saved
    boolean changed = !persister.getVersionType().isSame(persister.getVersion(target, source.getEnreplacedyMode()), persister.getVersion(enreplacedy, source.getEnreplacedyMode()), source.getEnreplacedyMode());
    // TODO : perhaps we should additionally require that the incoming enreplacedy
    // version be equivalent to the defined unsaved-value?
    return changed && existsInDatabase(target, source, persister);
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private boolean hasDirtyCollections(FlushEnreplacedyEvent event, EnreplacedyPersister persister, Status status) {
    if (isCollectionDirtyCheckNecessary(persister, status)) {
        DirtyCollectionSearchVisitor visitor = new DirtyCollectionSearchVisitor(event.getSession(), persister.getPropertyVersionability());
        visitor.processEnreplacedyPropertyValues(event.getPropertyValues(), persister.getPropertyTypes());
        boolean hasDirtyCollections = visitor.wasDirtyCollectionFound();
        event.setHasDirtyCollection(hasDirtyCollections);
        return hasDirtyCollections;
    } else {
        return false;
    }
}

19 View Complete Implementation : AbstractSaveEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Prepares the save call using a newly generated id.
 *
 * @param enreplacedy The enreplacedy to be saved
 * @param enreplacedyName The enreplacedy-name for the enreplacedy to be saved
 * @param anything Generally cascade-specific information.
 * @param source The session which is the source of this save event.
 * @param requiresImmediateIdAccess does the event context require
 * access to the identifier immediately after execution of this method (if
 * not, post-insert style id generators may be postponed if we are outside
 * a transaction).
 *
 * @return The id used to save the enreplacedy; may be null depending on the
 *         type of id generator used and the requiresImmediateIdAccess value
 */
protected Serializable saveWithGeneratedId(Object enreplacedy, String enreplacedyName, Object anything, EventSource source, boolean requiresImmediateIdAccess) {
    EnreplacedyPersister persister = source.getEnreplacedyPersister(enreplacedyName, enreplacedy);
    Serializable generatedId = persister.getIdentifierGenerator().generate(source, enreplacedy);
    if (generatedId == null) {
        throw new IdentifierGenerationException("null id generated for:" + enreplacedy.getClreplaced());
    } else if (generatedId == IdentifierGeneratorFactory.SHORT_CIRCUIT_INDICATOR) {
        return source.getIdentifier(enreplacedy);
    } else if (generatedId == IdentifierGeneratorFactory.POST_INSERT_INDICATOR) {
        return performSave(enreplacedy, null, persister, true, anything, source, requiresImmediateIdAccess);
    } else {
        if (log.isDebugEnabled()) {
            log.debug("generated identifier: " + persister.getIdentifierType().toLoggableString(generatedId, source.getFactory()) + ", using strategy: " + persister.getIdentifierGenerator().getClreplaced().getName());
        }
        return performSave(enreplacedy, generatedId, persister, false, anything, source, true);
    }
}

19 View Complete Implementation : FromElementFactory.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
FromElement addFromElement() throws SemanticException {
    FromClause parentFromClause = fromClause.getParentFromClause();
    if (parentFromClause != null) {
        // Look up clreplaced name using the first identifier in the path.
        String pathAlias = PathHelper.getAlias(path);
        FromElement parentFromElement = parentFromClause.getFromElement(pathAlias);
        if (parentFromElement != null) {
            return createFromElementInSubselect(path, pathAlias, parentFromElement, clreplacedAlias);
        }
    }
    EnreplacedyPersister enreplacedyPersister = fromClause.getSessionFactoryHelper().requireClreplacedPersister(path);
    FromElement elem = createAndAddFromElement(path, clreplacedAlias, enreplacedyPersister, (EnreplacedyType) ((Queryable) enreplacedyPersister).getType(), null);
    // Add to the query spaces.
    fromClause.getWalker().addQuerySpaces(enreplacedyPersister.getQuerySpaces());
    return elem;
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected boolean handleInterception(FlushEnreplacedyEvent event) {
    SessionImplementor session = event.getSession();
    EnreplacedyEntry entry = event.getEnreplacedyEntry();
    EnreplacedyPersister persister = entry.getPersister();
    Object enreplacedy = event.getEnreplacedy();
    // give the Interceptor a chance to modify property values
    final Object[] values = event.getPropertyValues();
    final boolean intercepted = invokeInterceptor(session, enreplacedy, entry, values, persister);
    // now we might need to recalculate the dirtyProperties array
    if (intercepted && event.isDirtyCheckPossible() && !event.isDirtyCheckHandledByInterceptor()) {
        int[] dirtyProperties;
        if (event.hasDatabaseSnapshot()) {
            dirtyProperties = persister.findModified(event.getDatabaseSnapshot(), values, enreplacedy, session);
        } else {
            dirtyProperties = persister.findDirty(values, entry.getLoadedState(), enreplacedy, session);
        }
        event.setDirtyProperties(dirtyProperties);
    }
    return intercepted;
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private boolean wrapCollections(EventSource session, EnreplacedyPersister persister, Type[] types, Object[] values) {
    if (persister.hasCollections()) {
        // wrap up any new collections directly referenced by the object
        // or its components
        // NOTE: we need to do the wrap here even if its not "dirty",
        // because collections need wrapping but changes to _them_
        // don't dirty the container. Also, for versioned data, we
        // need to wrap before calling searchForDirtyCollections
        WrapVisitor visitor = new WrapVisitor(session);
        // subsreplacedutes into values by side-effect
        visitor.processEnreplacedyPropertyValues(values, types);
        return visitor.isSubsreplacedutionRequired();
    } else {
        return false;
    }
}

19 View Complete Implementation : DefaultDeleteEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected void cascadeBeforeDelete(EventSource session, EnreplacedyPersister persister, Object enreplacedy, EnreplacedyEntry enreplacedyEntry, Set transientEnreplacedies) throws HibernateException {
    CacheMode cacheMode = session.getCacheMode();
    session.setCacheMode(CacheMode.GET);
    session.getPersistenceContext().incrementCascadeLevel();
    try {
        // cascade-delete to collections BEFORE the collection owner is deleted
        new Cascade(CascadingAction.DELETE, Cascade.AFTER_INSERT_BEFORE_DELETE, session).cascade(persister, enreplacedy, transientEnreplacedies);
    } finally {
        session.getPersistenceContext().decrementCascadeLevel();
        session.setCacheMode(cacheMode);
    }
}

19 View Complete Implementation : PostDeleteEvent.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Occurs after deleting an item from the datastore
 *
 * @author Gavin King
 */
public clreplaced PostDeleteEvent extends AbstractEvent {

    private Object enreplacedy;

    private EnreplacedyPersister persister;

    private Serializable id;

    private Object[] deletedState;

    public PostDeleteEvent(Object enreplacedy, Serializable id, Object[] deletedState, EnreplacedyPersister persister, EventSource source) {
        super(source);
        this.enreplacedy = enreplacedy;
        this.id = id;
        this.persister = persister;
        this.deletedState = deletedState;
    }

    public Serializable getId() {
        return id;
    }

    public EnreplacedyPersister getPersister() {
        return persister;
    }

    public Object getEnreplacedy() {
        return enreplacedy;
    }

    public Object[] getDeletedState() {
        return deletedState;
    }
}

19 View Complete Implementation : DefaultLoadEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Based on configured options, will either return a pre-existing proxy,
 * generate a new proxy, or perform an actual load.
 *
 * @return The result of the proxy/load operation.
 * @throws HibernateException
 */
protected Object proxyOrLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) throws HibernateException {
    if (log.isTraceEnabled()) {
        log.trace("loading enreplacedy: " + MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
    }
    if (!persister.hasProxy()) {
        // this clreplaced has no proxies (so do a shortcut)
        return load(event, persister, keyToLoad, options);
    } else {
        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);
        } else {
            if (options.isAllowProxyCreation()) {
                return createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext);
            } else {
                // return a newly loaded object
                return load(event, persister, keyToLoad, options);
            }
        }
    }
}

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Search the persistence context for an owner for the child object,
 * given a collection role. If <tt>mergeMap</tt> is non-null, also
 * check the detached graph being merged for a parent.
 */
public Serializable getOwnerId(String enreplacedy, String property, Object childEnreplacedy, Map mergeMap) {
    EnreplacedyPersister persister = session.getFactory().getEnreplacedyPersister(enreplacedy);
    final CollectionPersister collectionPersister = session.getFactory().getCollectionPersister(enreplacedy + '.' + property);
    Iterator enreplacedies = enreplacedyEntries.entrySet().iterator();
    while (enreplacedies.hasNext()) {
        Map.Entry me = (Map.Entry) enreplacedies.next();
        EnreplacedyEntry ee = (EnreplacedyEntry) me.getValue();
        if (persister.isSubclreplacedEnreplacedyName(ee.getEnreplacedyName())) {
            Object instance = me.getKey();
            // check if the managed object is the parent
            boolean found = isFoundInParent(property, childEnreplacedy, persister, collectionPersister, instance);
            if (!found && mergeMap != null) {
                // check if the detached object being merged is the parent
                Object unmergedInstance = mergeMap.get(instance);
                Object unmergedChild = mergeMap.get(childEnreplacedy);
                if (unmergedInstance != null && unmergedChild != null) {
                    found = isFoundInParent(property, unmergedChild, persister, collectionPersister, unmergedInstance);
                }
            }
            if (found) {
                return ee.getId();
            }
        }
    }
    return null;
}

19 View Complete Implementation : PreDeleteEvent.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Occurs before deleting an item from the datastore
 *
 * @author Gavin King
 */
public clreplaced PreDeleteEvent {

    private Object enreplacedy;

    private EnreplacedyPersister persister;

    private Serializable id;

    private Object[] deletedState;

    public Object getEnreplacedy() {
        return enreplacedy;
    }

    public Serializable getId() {
        return id;
    }

    public EnreplacedyPersister getPersister() {
        return persister;
    }

    public Object[] getDeletedState() {
        return deletedState;
    }

    public PreDeleteEvent(Object enreplacedy, Serializable id, Object[] deletedState, EnreplacedyPersister persister) {
        this.enreplacedy = enreplacedy;
        this.persister = persister;
        this.id = id;
        this.deletedState = deletedState;
    }
}

19 View Complete Implementation : Versioning.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Extract the optimisitc locking value out of the enreplacedy state snapshot.
 *
 * @param fields The state snapshot
 * @param persister The enreplacedy persister
 * @return The extracted optimisitc locking value
 */
public static Object getVersion(Object[] fields, EnreplacedyPersister persister) {
    if (!persister.isVersioned()) {
        return null;
    }
    return fields[persister.getVersionProperty()];
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * make sure user didn't mangle the id
 */
public void checkId(Object object, EnreplacedyPersister persister, Serializable id, EnreplacedyMode enreplacedyMode) throws HibernateException {
    if (id != null && id instanceof DelayedPostInsertIdentifier) {
        // this is a situation where the enreplacedy id is replacedigned by a post-insert generator
        // and was saved outside the transaction forcing it to be delayed
        return;
    }
    if (persister.canExtractIdOutOfEnreplacedy()) {
        Serializable oid = persister.getIdentifier(object, enreplacedyMode);
        if (id == null) {
            throw new replacedertionFailure("null id in " + persister.getEnreplacedyName() + " entry (don't flush the Session after an exception occurs)");
        }
        if (!persister.getIdentifierType().isEqual(id, oid, enreplacedyMode)) {
            throw new HibernateException("identifier of an instance of " + persister.getEnreplacedyName() + " was altered from " + id + " to " + oid);
        }
    }
}

19 View Complete Implementation : DefaultMergeEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private boolean existsInDatabase(Object enreplacedy, EventSource source, EnreplacedyPersister persister) {
    EnreplacedyEntry entry = source.getPersistenceContext().getEntry(enreplacedy);
    if (entry == null) {
        Serializable id = persister.getIdentifier(enreplacedy, source.getEnreplacedyMode());
        if (id != null) {
            EnreplacedyKey key = new EnreplacedyKey(id, persister, source.getEnreplacedyMode());
            Object managedEnreplacedy = source.getPersistenceContext().getEnreplacedy(key);
            entry = source.getPersistenceContext().getEntry(managedEnreplacedy);
        }
    }
    if (entry == null) {
        // perhaps this should be an exception since it is only ever used
        // in the above method?
        return false;
    } else {
        return entry.isExistsInDatabase();
    }
}

19 View Complete Implementation : StructuredCacheEntry.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * @author Gavin King
 */
public clreplaced StructuredCacheEntry implements CacheEntryStructure {

    private EnreplacedyPersister persister;

    public StructuredCacheEntry(EnreplacedyPersister persister) {
        this.persister = persister;
    }

    public Object destructure(Object item, SessionFactoryImplementor factory) {
        Map map = (Map) item;
        boolean lazyPropertiesUnfetched = ((Boolean) map.get("_lazyPropertiesUnfetched")).booleanValue();
        String subclreplaced = (String) map.get("_subclreplaced");
        Object version = map.get("_version");
        EnreplacedyPersister subclreplacedPersister = factory.getEnreplacedyPersister(subclreplaced);
        String[] names = subclreplacedPersister.getPropertyNames();
        Serializable[] state = new Serializable[names.length];
        for (int i = 0; i < names.length; i++) {
            state[i] = (Serializable) map.get(names[i]);
        }
        return new CacheEntry(state, subclreplaced, lazyPropertiesUnfetched, version);
    }

    public Object structure(Object item) {
        CacheEntry entry = (CacheEntry) item;
        String[] names = persister.getPropertyNames();
        Map map = new HashMap(names.length + 2);
        map.put("_subclreplaced", entry.getSubclreplaced());
        map.put("_version", entry.getVersion());
        map.put("_lazyPropertiesUnfetched", entry.areLazyPropertiesUnfetched() ? Boolean.TRUE : Boolean.FALSE);
        for (int i = 0; i < names.length; i++) {
            map.put(names[i], entry.getDisreplacedembledState()[i]);
        }
        return map;
    }
}

19 View Complete Implementation : ManyToOneType.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Register the enreplacedy as batch loadable, if enabled
 */
private void scheduleBatchLoadIfNeeded(Serializable id, SessionImplementor session) throws MappingException {
    // cannot batch fetch by unique key (property-ref replacedociations)
    if (uniqueKeyPropertyName == null && id != null) {
        EnreplacedyPersister persister = session.getFactory().getEnreplacedyPersister(getreplacedociatedEnreplacedyName());
        EnreplacedyKey enreplacedyKey = new EnreplacedyKey(id, persister, session.getEnreplacedyMode());
        if (!session.getPersistenceContext().containsEnreplacedy(enreplacedyKey)) {
            session.getPersistenceContext().getBatchFetchQueue().addBatchLoadableEnreplacedyKey(enreplacedyKey);
        }
    }
}

19 View Complete Implementation : DefaultDeleteEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * We encountered a delete request on a transient instance.
 * <p/>
 * This is a deviation from historical Hibernate (pre-3.2) behavior to
 * align with the JPA spec, which states that transient enreplacedies can be
 * preplaceded to remove operation in which case cascades still need to be
 * performed.
 *
 * @param session The session which is the source of the event
 * @param enreplacedy The enreplacedy being delete processed
 * @param cascadeDeleteEnabled Is cascading of deletes enabled
 * @param persister The enreplacedy persister
 * @param transientEnreplacedies A cache of already visited transient enreplacedies
 * (to avoid infinite recursion).
 */
protected void deleteTransientEnreplacedy(EventSource session, Object enreplacedy, boolean cascadeDeleteEnabled, EnreplacedyPersister persister, Set transientEnreplacedies) {
    log.info("handling transient enreplacedy in delete processing");
    if (transientEnreplacedies.contains(enreplacedy)) {
        log.trace("already handled transient enreplacedy; skipping");
        return;
    }
    transientEnreplacedies.add(enreplacedy);
    cascadeBeforeDelete(session, persister, enreplacedy, null, transientEnreplacedies);
    cascadeAfterDelete(session, persister, enreplacedy, transientEnreplacedies);
}

19 View Complete Implementation : DefaultLoadEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Given that there is a pre-existing proxy.
 * Initialize it if necessary; narrow if necessary.
 */
private Object returnNarrowedProxy(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext, final Object proxy) {
    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);
}

19 View Complete Implementation : AbstractSaveEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected boolean invokeSaveLifecycle(Object enreplacedy, EnreplacedyPersister persister, EventSource source) {
    // Sub-insertions should occur before containing insertion so
    // Try to do the callback now
    if (persister.implementsLifecycle(source.getEnreplacedyMode())) {
        log.debug("calling onSave()");
        if (((Lifecycle) enreplacedy).onSave(source)) {
            log.debug("insertion vetoed by onSave()");
            return true;
        }
    }
    return false;
}

19 View Complete Implementation : DefaultDeleteEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected boolean invokeDeleteLifecycle(EventSource session, Object enreplacedy, EnreplacedyPersister persister) {
    if (persister.implementsLifecycle(session.getEnreplacedyMode())) {
        log.debug("calling onDelete()");
        if (((Lifecycle) enreplacedy).onDelete(session)) {
            log.debug("deletion vetoed by onDelete()");
            return true;
        }
    }
    return false;
}

19 View Complete Implementation : EntityType.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected final Object getIdentifier(Object value, SessionImplementor session) throws HibernateException {
    if (isNotEmbedded(session)) {
        return value;
    }
    if (isReferenceToPrimaryKey()) {
        // tolerates nulls
        return ForeignKeys.getEnreplacedyIdentifierIfNotUnsaved(getreplacedociatedEnreplacedyName(), value, session);
    } else if (value == null) {
        return null;
    } else {
        EnreplacedyPersister enreplacedyPersister = session.getFactory().getEnreplacedyPersister(getreplacedociatedEnreplacedyName());
        Object propertyValue = enreplacedyPersister.getPropertyValue(value, uniqueKeyPropertyName, session.getEnreplacedyMode());
        // We now have the value of the property-ref we reference.  However,
        // we need to dig a little deeper, as that property might also be
        // an enreplacedy type, in which case we need to resolve its idenreplacedifier
        Type type = enreplacedyPersister.getPropertyType(uniqueKeyPropertyName);
        if (type.isEnreplacedyType()) {
            propertyValue = ((EnreplacedyType) type).getIdentifier(propertyValue, session);
        }
        return propertyValue;
    }
}

19 View Complete Implementation : ForeignKeys.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Is this instance, which we know is not persistent, actually transient?
 * If <tt>replacedumed</tt> is non-null, don't hit the database to make the
 * determination, instead replacedume that value; the client code must be
 * prepared to "recover" in the case that this replacedumed result is incorrect.
 */
public static boolean isTransient(String enreplacedyName, Object enreplacedy, Boolean replacedumed, SessionImplementor session) throws HibernateException {
    if (enreplacedy == LazyPropertyInitializer.UNFETCHED_PROPERTY) {
        // an unfetched replacedociation can only point to
        // an enreplacedy that already exists in the db
        return false;
    }
    // let the interceptor inspect the instance to decide
    Boolean isUnsaved = session.getInterceptor().isTransient(enreplacedy);
    if (isUnsaved != null)
        return isUnsaved.booleanValue();
    // let the persister inspect the instance to decide
    EnreplacedyPersister persister = session.getEnreplacedyPersister(enreplacedyName, enreplacedy);
    isUnsaved = persister.isTransient(enreplacedy, session);
    if (isUnsaved != null)
        return isUnsaved.booleanValue();
    // we use the replacedumed value, if there is one, to avoid hitting
    // the database
    if (replacedumed != null)
        return replacedumed.booleanValue();
    // hit the database, after checking the session cache for a snapshot
    Object[] snapshot = session.getPersistenceContext().getDatabaseSnapshot(persister.getIdentifier(enreplacedy, session.getEnreplacedyMode()), persister);
    return snapshot == null;
}

19 View Complete Implementation : FromElementFactory.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private FromElement createFromElementInSubselect(String path, String pathAlias, FromElement parentFromElement, String clreplacedAlias) throws SemanticException {
    if (log.isDebugEnabled()) {
        log.debug("createFromElementInSubselect() : path = " + path);
    }
    // Create an DotNode AST for the path and resolve it.
    FromElement fromElement = evaluateFromElementPath(path, clreplacedAlias);
    EnreplacedyPersister enreplacedyPersister = fromElement.getEnreplacedyPersister();
    // If the first identifier in the path referrs to the clreplaced alias (not the clreplaced name), then this
    // is a correlated subselect.  If it's a correlated sub-select, use the existing table alias.  Otherwise
    // generate a new one.
    String tableAlias = null;
    boolean correlatedSubselect = pathAlias.equals(parentFromElement.getClreplacedAlias());
    if (correlatedSubselect) {
        tableAlias = fromElement.getTableAlias();
    } else {
        tableAlias = null;
    }
    // If the from element isn't in the same clause, create a new from element.
    if (fromElement.getFromClause() != fromClause) {
        if (log.isDebugEnabled()) {
            log.debug("createFromElementInSubselect() : creating a new FROM element...");
        }
        fromElement = createFromElement(enreplacedyPersister);
        initializeAndAddFromElement(fromElement, path, clreplacedAlias, enreplacedyPersister, (EnreplacedyType) ((Queryable) enreplacedyPersister).getType(), tableAlias);
    }
    if (log.isDebugEnabled()) {
        log.debug("createFromElementInSubselect() : " + path + " -> " + fromElement);
    }
    return fromElement;
}

19 View Complete Implementation : DefaultLoadEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * If the clreplaced to be loaded has been configured with a cache, then lock
 * given id in that cache and then perform the load.
 *
 * @return The loaded enreplacedy
 * @throws HibernateException
 */
protected Object lockAndLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final SessionImplementor source) throws HibernateException {
    CacheConcurrencyStrategy.SoftLock lock = null;
    final CacheKey ck;
    if (persister.hasCache()) {
        ck = new CacheKey(event.getEnreplacedyId(), persister.getIdentifierType(), persister.getRootEnreplacedyName(), source.getEnreplacedyMode(), source.getFactory());
        lock = persister.getCache().lock(ck, null);
    } else {
        ck = null;
    }
    Object enreplacedy;
    try {
        enreplacedy = load(event, persister, keyToLoad, options);
    } finally {
        if (persister.hasCache()) {
            persister.getCache().release(ck, lock);
        }
    }
    Object proxy = event.getSession().getPersistenceContext().proxyFor(persister, keyToLoad, enreplacedy);
    return proxy;
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Convience method to retreive an enreplacedies next version value
 */
private Object getNextVersion(FlushEnreplacedyEvent event) throws HibernateException {
    EnreplacedyEntry entry = event.getEnreplacedyEntry();
    EnreplacedyPersister persister = entry.getPersister();
    if (persister.isVersioned()) {
        Object[] values = event.getPropertyValues();
        if (entry.isBeingReplicated()) {
            return Versioning.getVersion(values, persister);
        } else {
            int[] dirtyProperties = event.getDirtyProperties();
            final boolean isVersionIncrementRequired = isVersionIncrementRequired(event, entry, persister, dirtyProperties);
            final Object nextVersion = isVersionIncrementRequired ? Versioning.increment(entry.getVersion(), persister.getVersionType(), event.getSession()) : // use the current version
            entry.getVersion();
            Versioning.setVersion(values, nextVersion, persister);
            return nextVersion;
        }
    } else {
        return null;
    }
}

19 View Complete Implementation : StatelessSessionImpl.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
public void refresh(String enreplacedyName, Object enreplacedy, LockMode lockMode) {
    final EnreplacedyPersister persister = this.getEnreplacedyPersister(enreplacedyName, enreplacedy);
    final Serializable id = persister.getIdentifier(enreplacedy, getEnreplacedyMode());
    if (log.isTraceEnabled()) {
        log.trace("refreshing transient " + MessageHelper.infoString(persister, id, this.getFactory()));
    }
    // TODO : can this ever happen???
    // EnreplacedyKey key = new EnreplacedyKey( id, persister, source.getEnreplacedyMode() );
    // if ( source.getPersistenceContext().getEntry( key ) != null ) {
    // throw new PersistentObjectException(
    // "attempted to refresh transient instance when persistent " +
    // "instance was already replacedociated with the Session: " +
    // MessageHelper.infoString( persister, id, source.getFactory() )
    // );
    // }
    if (persister.hasCache()) {
        final CacheKey ck = new CacheKey(id, persister.getIdentifierType(), persister.getRootEnreplacedyName(), this.getEnreplacedyMode(), this.getFactory());
        persister.getCache().remove(ck);
    }
    String previousFetchProfile = this.getFetchProfile();
    Object result = null;
    try {
        this.setFetchProfile("refresh");
        result = persister.load(id, enreplacedy, lockMode, this);
    } finally {
        this.setFetchProfile(previousFetchProfile);
    }
    UnresolvableObjectException.throwIfNull(result, id, persister.getEnreplacedyName());
}

19 View Complete Implementation : Cascade.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Cascade an action from the parent enreplacedy instance to all its children.
 *
 * @param persister The parent's enreplacedy persister
 * @param parent The parent reference.
 * @throws HibernateException
 */
public void cascade(final EnreplacedyPersister persister, final Object parent) throws HibernateException {
    cascade(persister, parent, null);
}

19 View Complete Implementation : StatefulPersistenceContext.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Get the current state of the enreplacedy as known to the underlying
 * database, or null if there is no corresponding row
 */
public Object[] getDatabaseSnapshot(Serializable id, EnreplacedyPersister persister) throws HibernateException {
    EnreplacedyKey key = new EnreplacedyKey(id, persister, session.getEnreplacedyMode());
    Object cached = enreplacedySnapshotsByKey.get(key);
    if (cached != null) {
        return cached == NO_ROW ? null : (Object[]) cached;
    } else {
        Object[] snapshot = persister.getDatabaseSnapshot(id, session);
        enreplacedySnapshotsByKey.put(key, snapshot == null ? NO_ROW : snapshot);
        return snapshot;
    }
}

19 View Complete Implementation : FromElement.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private void doInitialize(FromClause fromClause, String tableAlias, String clreplacedName, String clreplacedAlias, EnreplacedyPersister persister, EnreplacedyType type) {
    if (initialized) {
        throw new IllegalStateException("Already initialized!!");
    }
    this.fromClause = fromClause;
    this.tableAlias = tableAlias;
    this.clreplacedName = clreplacedName;
    this.clreplacedAlias = clreplacedAlias;
    this.elementType = new FromElementType(this, persister, type);
    // Register the FromElement with the FROM clause, now that we have the names and aliases.
    fromClause.registerFromElement(this);
    if (log.isDebugEnabled()) {
        log.debug(fromClause + " :  " + clreplacedName + " (" + (clreplacedAlias == null ? "no alias" : clreplacedAlias) + ") -> " + tableAlias);
    }
}

19 View Complete Implementation : StatelessSessionImpl.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
public Object internalLoad(String enreplacedyName, Serializable id, boolean eager, boolean nullable) throws HibernateException {
    errorIfClosed();
    EnreplacedyPersister persister = getFactory().getEnreplacedyPersister(enreplacedyName);
    if (!eager && persister.hasProxy()) {
        return persister.createProxy(id, this);
    }
    Object loaded = temporaryPersistenceContext.getEnreplacedy(new EnreplacedyKey(id, persister, EnreplacedyMode.POJO));
    // TODO: if not loaded, throw an exception
    return loaded == null ? get(enreplacedyName, id) : loaded;
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Performs all necessary checking to determine if an enreplacedy needs an SQL update
 * to synchronize its state to the database. Modifies the event by side-effect!
 * Note: this method is quite slow, avoid calling if possible!
 */
protected final boolean isUpdateNecessary(FlushEnreplacedyEvent event) throws HibernateException {
    EnreplacedyPersister persister = event.getEnreplacedyEntry().getPersister();
    Status status = event.getEnreplacedyEntry().getStatus();
    if (!event.isDirtyCheckPossible()) {
        return true;
    } else {
        int[] dirtyProperties = event.getDirtyProperties();
        if (dirtyProperties != null && dirtyProperties.length != 0) {
            // TODO: suck into event clreplaced
            return true;
        } else {
            return hasDirtyCollections(event, persister, status);
        }
    }
}

19 View Complete Implementation : DefaultFlushEntityEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private void checkNaturalId(EnreplacedyPersister persister, Serializable identifier, Object[] current, Object[] loaded, EnreplacedyMode enreplacedyMode, SessionImplementor session) {
    if (persister.hasNaturalIdentifier()) {
        Object[] snapshot = null;
        Type[] types = persister.getPropertyTypes();
        int[] props = persister.getNaturalIdentifierProperties();
        boolean[] updateable = persister.getPropertyUpdateability();
        for (int i = 0; i < props.length; i++) {
            int prop = props[i];
            if (!updateable[prop]) {
                Object loadedVal;
                if (loaded == null) {
                    if (snapshot == null) {
                        snapshot = session.getPersistenceContext().getNaturalIdSnapshot(identifier, persister);
                    }
                    loadedVal = snapshot[i];
                } else {
                    loadedVal = loaded[prop];
                }
                if (!types[prop].isEqual(current[prop], loadedVal, enreplacedyMode)) {
                    throw new HibernateException("immutable natural identifier of an instance of " + persister.getEnreplacedyName() + " was altered");
                }
            }
        }
    }
}

19 View Complete Implementation : AbstractSaveEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Perform any property value subsreplacedution that is necessary
 * (interceptor callback, version initialization...)
 *
 * @param enreplacedy The enreplacedy
 * @param id The enreplacedy identifier
 * @param values The snapshot enreplacedy state
 * @param persister The enreplacedy persister
 * @param source The originating session
 *
 * @return True if the snapshot state changed such that
 * reinjection of the values into the enreplacedy is required.
 */
protected boolean subsreplaceduteValuesIfNecessary(Object enreplacedy, Serializable id, Object[] values, EnreplacedyPersister persister, SessionImplementor source) {
    boolean subsreplacedute = source.getInterceptor().onSave(enreplacedy, id, values, persister.getPropertyNames(), persister.getPropertyTypes());
    // keep the existing version number in the case of replicate!
    if (persister.isVersioned()) {
        subsreplacedute = Versioning.seedVersion(values, persister.getVersionProperty(), persister.getVersionType(), source) || subsreplacedute;
    }
    return subsreplacedute;
}

19 View Complete Implementation : SessionFactoryHelper.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Locate the persister by clreplaced or enreplacedy name, requiring that such a persister
 * exist.
 *
 * @param name The clreplaced or enreplacedy name
 * @return The defined persister for this enreplacedy
 * @throws SemanticException Indicates the persister could not be found
 */
public EnreplacedyPersister requireClreplacedPersister(String name) throws SemanticException {
    EnreplacedyPersister cp;
    try {
        cp = findEnreplacedyPersisterByName(name);
        if (cp == null) {
            throw new QuerySyntaxException(name + " is not mapped");
        }
    } catch (MappingException e) {
        throw new DetailedSemanticException(e.getMessage(), e);
    }
    return cp;
}

19 View Complete Implementation : AbstractSaveEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Handles to calls needed to perform post-save cascades.
 *
 * @param source The session from which the event originated.
 * @param persister The enreplacedy's persister instance.
 * @param enreplacedy The enreplacedy beng saved.
 * @param anything Generally cascade-specific data
 */
protected void cascadeAfterSave(EventSource source, EnreplacedyPersister persister, Object enreplacedy, Object anything) {
    // cascade-save to collections AFTER the collection owner was saved
    source.getPersistenceContext().incrementCascadeLevel();
    try {
        new Cascade(getCascadeAction(), Cascade.AFTER_INSERT_BEFORE_DELETE, source).cascade(persister, enreplacedy, anything);
    } finally {
        source.getPersistenceContext().decrementCascadeLevel();
    }
}

19 View Complete Implementation : DefaultLoadEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
private Object replacedembleCacheEntry(final CacheEntry entry, final Serializable id, final EnreplacedyPersister persister, final LoadEvent event) throws HibernateException {
    final Object optionalObject = event.getInstanceToLoad();
    final EventSource session = event.getSession();
    final SessionFactoryImplementor factory = session.getFactory();
    if (log.isTraceEnabled()) {
        log.trace("replacedembling enreplacedy from second-level cache: " + MessageHelper.infoString(persister, id, factory));
    }
    EnreplacedyPersister subclreplacedPersister = factory.getEnreplacedyPersister(entry.getSubclreplaced());
    Object result = optionalObject == null ? session.instantiate(subclreplacedPersister, id) : optionalObject;
    // make it circular-reference safe
    TwoPhaseLoad.addUninitializedCachedEnreplacedy(new EnreplacedyKey(id, subclreplacedPersister, session.getEnreplacedyMode()), result, subclreplacedPersister, LockMode.NONE, entry.areLazyPropertiesUnfetched(), entry.getVersion(), session);
    Type[] types = subclreplacedPersister.getPropertyTypes();
    // intializes result by side-effect
    Object[] values = entry.replacedemble(result, id, subclreplacedPersister, session.getInterceptor(), session);
    TypeFactory.deepCopy(values, types, subclreplacedPersister.getPropertyUpdateability(), values, session);
    Object version = Versioning.getVersion(values, subclreplacedPersister);
    if (log.isTraceEnabled())
        log.trace("Cached Version: " + version);
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    persistenceContext.addEntry(result, Status.MANAGED, values, null, id, version, LockMode.NONE, true, subclreplacedPersister, false, entry.areLazyPropertiesUnfetched());
    subclreplacedPersister.afterInitialize(result, entry.areLazyPropertiesUnfetched(), session);
    persistenceContext.initializeNonLazyCollections();
    // upgrade the lock if necessary:
    // lock(result, lockMode);
    // PostLoad is needed for EJB3
    // TODO: reuse the PostLoadEvent...
    PostLoadEvent postLoadEvent = new PostLoadEvent(session).setEnreplacedy(result).setId(id).setPersister(persister);
    PostLoadEventListener[] listeners = session.getListeners().getPostLoadEventListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].onPostLoad(postLoadEvent);
    }
    return result;
}

19 View Complete Implementation : PostInsertEvent.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Occurs after inserting an item in the datastore
 *
 * @author Gavin King
 */
public clreplaced PostInsertEvent extends AbstractEvent {

    private Object enreplacedy;

    private EnreplacedyPersister persister;

    private Object[] state;

    private Serializable id;

    public PostInsertEvent(Object enreplacedy, Serializable id, Object[] state, EnreplacedyPersister persister, EventSource source) {
        super(source);
        this.enreplacedy = enreplacedy;
        this.id = id;
        this.state = state;
        this.persister = persister;
    }

    public Object getEnreplacedy() {
        return enreplacedy;
    }

    public Serializable getId() {
        return id;
    }

    public EnreplacedyPersister getPersister() {
        return persister;
    }

    public Object[] getState() {
        return state;
    }
}

19 View Complete Implementation : DefaultSaveOrUpdateEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
protected boolean invokeUpdateLifecycle(Object enreplacedy, EnreplacedyPersister persister, EventSource source) {
    if (persister.implementsLifecycle(source.getEnreplacedyMode())) {
        log.debug("calling onUpdate()");
        if (((Lifecycle) enreplacedy).onUpdate(source)) {
            log.debug("update vetoed by onUpdate()");
            return true;
        }
    }
    return false;
}

19 View Complete Implementation : SessionFactoryImpl.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
public void evict(Clreplaced persistentClreplaced, Serializable id) throws HibernateException {
    EnreplacedyPersister p = getEnreplacedyPersister(persistentClreplaced.getName());
    if (p.hasCache()) {
        if (log.isDebugEnabled()) {
            log.debug("evicting second-level cache: " + MessageHelper.infoString(p, id, this));
        }
        CacheKey cacheKey = new CacheKey(id, p.getIdentifierType(), p.getRootEnreplacedyName(), EnreplacedyMode.POJO, this);
        p.getCache().remove(cacheKey);
    }
}

19 View Complete Implementation : JoinWalker.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Does the mapping, and Hibernate default semantics, specify that
 * this replacedociation should be fetched by outer joining
 */
protected boolean isJoinedFetchEnabledInMapping(FetchMode config, replacedociationType type) throws MappingException {
    if (!type.isEnreplacedyType() && !type.isCollectionType()) {
        return false;
    } else {
        if (config == FetchMode.JOIN)
            return true;
        if (config == FetchMode.SELECT)
            return false;
        if (type.isEnreplacedyType()) {
            // TODO: look at the owning property and check that it
            // isn't lazy (by instrumentation)
            EnreplacedyType enreplacedyType = (EnreplacedyType) type;
            EnreplacedyPersister persister = getFactory().getEnreplacedyPersister(enreplacedyType.getreplacedociatedEnreplacedyName());
            return !persister.hasProxy();
        } else {
            return false;
        }
    }
}

19 View Complete Implementation : DefaultMergeEventListener.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Perform any cascades needed as part of this copy event.
 *
 * @param source The merge event being processed.
 * @param persister The persister of the enreplacedy being copied.
 * @param enreplacedy The enreplacedy being copied.
 * @param copyCache A cache of already copied instance.
 */
protected void cascadeOnMerge(final EventSource source, final EnreplacedyPersister persister, final Object enreplacedy, final Map copyCache) {
    source.getPersistenceContext().incrementCascadeLevel();
    try {
        new Cascade(getCascadeAction(), Cascade.BEFORE_MERGE, source).cascade(persister, enreplacedy, copyCache);
    } finally {
        source.getPersistenceContext().decrementCascadeLevel();
    }
}