@Override public void setPersistenceDelegator(PersistenceDelegator pd) { this.pd = pd; setPersistenceCache(pd.getPersistenceCache()); }
/** * Check if the instance is a managed entity instance belonging to the * current persistence context. */ boolean contains(Object entity) { Node node = getPersistenceCache().getMainCache().getNodeFromCache(entity, getMetadata(entity.getClass()), this); return node != null && node.isInState(ManagedState.class); }
void clear() { // Move all nodes tied to this EM into detached state flushManager.clearFlushStack(); getPersistenceCache().clean(); onClearProxy(); }
/** * @param entity * @param pd * @param entityId */ public static void addEntityToPersistenceCache(Object entity, PersistenceDelegator pd, Object entityId) { MainCache mainCache = (MainCache) pd.getPersistenceCache().getMainCache(); String nodeId = ObjectGraphUtils.getNodeId(entityId, entity.getClass()); Node node = new Node(nodeId, entity.getClass(), new ManagedState(), pd.getPersistenceCache(), entityId, pd); node.setData(entity); node.setPersistenceDelegator(pd); mainCache.addNodeToCache(node); }
/** * Remove the given entity from the persistence context, causing a managed * entity to become detached. */ public void detach(Object entity) { Node node = getPersistenceCache().getMainCache().getNodeFromCache(entity, getMetadata(entity.getClass()), this); if (node != null) { node.detach(); } }
void rollback() { flushManager.rollback(this); flushManager.clearFlushStack(); getPersistenceCache().clean(); isTransactionInProgress = false; }
/** * Refresh the state of the instance from the database, overwriting changes * made to the entity, if any. */ public void refresh(Object entity) { if (contains(entity)) { MainCache mainCache = (MainCache) getPersistenceCache().getMainCache(); Node node = mainCache.getNodeFromCache(entity, getMetadata(entity.getClass()), this); // Locking as it might read from persistence context. try { lock.readLock().lock(); node.setPersistenceDelegator(this); node.refresh(); } finally { lock.readLock().unlock(); } } else { throw new IllegalArgumentException("This is not a valid or managed entity, can't be refreshed"); } }
/** * Generate entity graph and returns after assigning headnode. n * * @param entity * entity. * @param delegator * delegator * @param pc * persistence cache * @return object graph. */ public <E> ObjectGraph generateGraph(E entity, PersistenceDelegator delegator) { this.builder.assign(this); Node node = generate(entity, delegator, delegator.getPersistenceCache(), null); this.builder.assignHeadNode(node); return this.builder.getGraph(); }
/** * Generate entity graph and returns after assigning headnode. n * * @param entity * entity. * @param delegator * delegator * @param pc * persistence cache * @return object graph. */ public <E> ObjectGraph generateGraph(E entity, PersistenceDelegator delegator, NodeState state) { this.builder.assign(this); Node node = generate(entity, delegator, delegator.getPersistenceCache(), state); this.builder.assignHeadNode(node); return this.builder.getGraph(); }
getPersistenceCache().getMainCache().addHeadNode(node);
Node nodeInPersistenceCache = pd.getPersistenceCache().getMainCache().getNodeFromCache(nodeId, pd); entity, ((Field) entityMetadata.getIdAttribute().getJavaMember()).isAnnotationPresent(EmbeddedId.class) ? new ManagedState() : this.state, pd.getPersistenceCache(), entityId, pd); node.setPersistenceCache(pd.getPersistenceCache()); node.setTraversed(false);
MainCache mainCache = (MainCache) getPersistenceCache().getMainCache(); Node node = mainCache.getNodeFromCache(nodeId, this); node = new Node(nodeId, entityClass, new ManagedState(), getPersistenceCache(), primaryKey, this); node.setClient(getClient(entityMetadata));
.getPersistenceCache() .getMainCache() .getNodeFromCache( .getPersistenceCache() .getMainCache() .getNodeFromCache( .getPersistenceCache() .getMainCache() .getNodeFromCache(