public CDORevisionDeltaImpl(CDORevisionDelta revisionDelta, boolean copyFeatureDeltas) { eClass = revisionDelta.getEClass(); id = revisionDelta.getID(); branch = revisionDelta.getBranch(); version = revisionDelta.getVersion(); if (copyFeatureDeltas) { for (CDOFeatureDelta delta : revisionDelta.getFeatureDeltas()) { addFeatureDelta(((InternalCDOFeatureDelta)delta).copy()); } } }
public void process(IDBStoreAccessor accessor, CDORevisionDelta delta, long created) { try { // Set context id = delta.getID(); branchId = delta.getBranch().getID(); oldVersion = delta.getVersion(); newVersion = oldVersion + 1; this.created = created; this.accessor = accessor; // Process revision delta tree delta.accept(this); updateAttributes(); } finally { // Clean up reset(); } }
@Override public CDOID getID() { return targetDelta.getID(); }
CDOID id = revisionDelta.getID(); if (!isNewObject(id)) if (oldRevisionDelta == null) allRevisionDeltas.put(id, revisionDelta.copy()); for (CDOFeatureDelta delta : revisionDelta.getFeatureDeltas())
public static boolean canHaveResourcePathImpact(CDORevisionDelta delta, CDOID rootResourceID) EClass eClass = delta.getEClass(); if (EresourcePackage.Literals.CDO_RESOURCE_NODE.isSuperTypeOf(eClass)) if (delta.getFeatureDelta(EresourcePackage.Literals.CDO_RESOURCE_NODE__NAME) != null) .getFeatureDelta(EresourcePackage.Literals.CDO_RESOURCE_FOLDER__NODES); if (canHaveResourcePathImpact(featureDelta)) if (rootResourceID == delta.getID()) .getFeatureDelta(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS); if (canHaveResourcePathImpact(featureDelta))
protected boolean hasFeatureConflicts(CDORevisionDelta localDelta, List<CDORevisionDelta> remoteDeltas) { Set<EStructuralFeature> features = new HashSet<EStructuralFeature>(); for (CDOFeatureDelta localFeatureDelta : localDelta.getFeatureDeltas()) { features.add(localFeatureDelta.getFeature()); } for (CDORevisionDelta remoteDelta : remoteDeltas) { for (CDOFeatureDelta remoteFeatureDelta : remoteDelta.getFeatureDeltas()) { EStructuralFeature feature = remoteFeatureDelta.getFeature(); if (features.contains(feature)) { return true; } } } return false; } }
private Pair<InternalCDORevision, InternalCDORevision> createNewRevision(CDORevisionKey potentialDelta, CDOCommitInfo commitInfo) { if (potentialDelta instanceof CDORevisionDelta) { CDORevisionDelta delta = (CDORevisionDelta)potentialDelta; CDOID id = delta.getID(); InternalCDORevisionManager revisionManager = getRevisionManager(); InternalCDORevision oldRevision = revisionManager.getRevisionByVersion(id, potentialDelta, CDORevision.UNCHUNKED, false); if (oldRevision != null) { InternalCDORevision newRevision = oldRevision.copy(); newRevision.adjustForCommit(commitInfo.getBranch(), commitInfo.getTimeStamp()); CDORevisable target = delta.getTarget(); if (target != null) { newRevision.setVersion(target.getVersion()); } delta.apply(newRevision); newRevision.freeze(); return new Pair<InternalCDORevision, InternalCDORevision>(oldRevision, newRevision); } } return null; }
private void processRevisionDeltas(InternalEObject reattachedObject, InternalCDOTransaction transaction) { InternalCDOSavepoint lastSavepoint = transaction.getLastSavepoint(); Map<CDOID, CDORevisionDelta> revisionDeltas = lastSavepoint.getRevisionDeltas2(); for (Iterator<Entry<CDOID, CDORevisionDelta>> it = revisionDeltas.entrySet().iterator(); it.hasNext();) { Entry<CDOID, CDORevisionDelta> entry = it.next(); CDORevisionDelta revisionDelta = entry.getValue(); Map<EStructuralFeature, CDOFeatureDelta> map = ((InternalCDORevisionDelta)revisionDelta).getFeatureDeltaMap(); processFeatureDeltas(reattachedObject, map); if (revisionDelta.isEmpty()) { it.remove(); CDOID id = revisionDelta.getID(); InternalCDOObject cleanObject = (InternalCDOObject)lastSavepoint.getDirtyObjects().remove(id); cleanObject.cdoInternalSetState(CDOState.CLEAN); } } if (revisionDeltas.isEmpty()) { transaction.setDirty(false); } }
final CDORevision oldRevision = revisionManager.getRevisionByVersion(revisionDelta.getID(), revisionDelta, CDORevision.UNCHUNKED, false); for (CDOFeatureDelta featureDelta : revisionDelta.getFeatureDeltas())
private void mergeChangedObject(CDORevisionKey key, Map<CDOID, CDOIDAndVersion> newMap, Map<CDOID, CDORevisionKey> changedMap) { CDOID id = key.getID(); if (key instanceof CDORevisionDelta) { CDORevisionDelta delta = (CDORevisionDelta)key; // Try to add the delta to existing new revision CDOIDAndVersion oldRevision = newMap.get(id); if (oldRevision instanceof CDORevision) { CDORevision newRevision = (CDORevision)oldRevision; delta.apply(newRevision); return; } // Try to add the delta to existing delta CDORevisionKey oldDelta = changedMap.get(id); if (oldDelta instanceof CDORevisionDelta) { InternalCDORevisionDelta newDelta = (InternalCDORevisionDelta)oldDelta; for (CDOFeatureDelta featureDelta : delta.getFeatureDeltas()) { newDelta.addFeatureDelta(featureDelta); } return; } } // Fall back changedMap.put(id, key); }
private void registerInactivationOrUpdate(final EClass eClass, final String conceptId, final String componentId, CDORevisionDelta revisionDelta) { CDOSetFeatureDelta activeDelta = (CDOSetFeatureDelta) revisionDelta.getFeatureDelta(SnomedPackage.Literals.COMPONENT__ACTIVE); if (activeDelta != null && Boolean.FALSE.equals(activeDelta.getValue())) { entry.registerChange(conceptId, new TraceabilityChange(eClass, componentId, ChangeType.INACTIVATE)); } else { for (CDOFeatureDelta featureDelta : revisionDelta.getFeatureDeltas()) { if (!IGNORED_FEATURES.contains(featureDelta.getFeature())) { entry.registerChange(conceptId, new TraceabilityChange(eClass, componentId, ChangeType.UPDATE)); } } } }
public synchronized void merge(InternalCDORevision revision, CDORevisionDelta delta) { this.revision = revision; delta.accept(this); revision = null; }
private boolean isReleased(final CDORevisionDelta revisionDelta, final EAttribute releasedAttribute) { final CDOFeatureDelta releasedFeatureDelta = revisionDelta.getFeatureDelta(releasedAttribute); if (releasedFeatureDelta instanceof CDOSetFeatureDelta) { return (boolean) ((CDOSetFeatureDelta) releasedFeatureDelta).getValue(); } return false; }
private Conflict checkIsReleasedState(final CDORevisionDelta revisionDelta) { final EClass eClass = revisionDelta.getEClass(); Optional<EClass> releasableClass = FluentIterable.from(releasedAttributeMap.keySet()).firstMatch(new Predicate<EClass>() { @Override public boolean apply(EClass input) { return input.isSuperTypeOf(eClass); } }); if (releasableClass.isPresent() && isReleased(revisionDelta, releasedAttributeMap.get(releasableClass.get()))) { return new ChangedInTargetAndDetachedInSourceConflict(revisionDelta); } return null; }
changedObjectsCopy.add(delta.copy());
InternalCDORevision newCleanRevision = cleanRevision.copy(); newCleanRevision.setVersion(newVersion); remoteDelta.apply(newCleanRevision);