Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.hibernate.envers.synchronization.work;
import java.io.Serializable;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.envers.RevisionType;
import org.hibernate.envers.configuration.AuditConfiguration;
import org.hibernate.envers.entities.RelationDescription;
/**
* A work unit that handles "fake" bidirectional one-to-many relations (mapped with {@code @OneToMany+@JoinColumn} and
* {@code @ManyToOne+@Column(insertable=false, updatable=false)}.
* @author Adam Warski (adam at warski dot org)
*/
public class FakeBidirectionalRelationWorkUnit extends AbstractAuditWorkUnit implements AuditWorkUnit {
private final Map fakeRelationChanges;
/*
* The work unit responsible for generating the "raw" entity data to be saved.
*/
private final AuditWorkUnit nestedWorkUnit;
public FakeBidirectionalRelationWorkUnit(SessionImplementor sessionImplementor, String entityName,
AuditConfiguration verCfg, Serializable id,
String referencingPropertyName, Object owningEntity,
RelationDescription rd, RevisionType revisionType,
Object index,
AuditWorkUnit nestedWorkUnit) {
super(sessionImplementor, entityName, verCfg, id, revisionType);
this.nestedWorkUnit = nestedWorkUnit;
// Adding the change for the relation.
fakeRelationChanges = new HashMap();
fakeRelationChanges.put(referencingPropertyName, new FakeRelationChange(owningEntity, rd, revisionType, index));
}
public FakeBidirectionalRelationWorkUnit(FakeBidirectionalRelationWorkUnit original,
Map fakeRelationChanges,
AuditWorkUnit nestedWorkUnit) {
super(original.sessionImplementor, original.entityName, original.verCfg, original.id, original.revisionType);
this.fakeRelationChanges = fakeRelationChanges;
this.nestedWorkUnit = nestedWorkUnit;
}
public FakeBidirectionalRelationWorkUnit(FakeBidirectionalRelationWorkUnit original, AuditWorkUnit nestedWorkUnit) {
super(original.sessionImplementor, original.entityName, original.verCfg, original.id, original.revisionType);
this.nestedWorkUnit = nestedWorkUnit;
fakeRelationChanges = new HashMap(original.getFakeRelationChanges());
}
public AuditWorkUnit getNestedWorkUnit() {
return nestedWorkUnit;
}
public Map getFakeRelationChanges() {
return fakeRelationChanges;
}
public boolean containsWork() {
return true;
}
public Map generateData(Object revisionData) {
// Generating data with the nested work unit. This data contains all data except the fake relation.
// Making a defensive copy not to modify the data held by the nested work unit.
Map nestedData = new HashMap(nestedWorkUnit.generateData(revisionData));
// Now adding data for all fake relations.
for (FakeRelationChange fakeRelationChange : fakeRelationChanges.values()) {
fakeRelationChange.generateData(sessionImplementor, nestedData);
}
return nestedData;
}
public AuditWorkUnit merge(AddWorkUnit second) {
return merge(this, nestedWorkUnit, second);
}
public AuditWorkUnit merge(ModWorkUnit second) {
return merge(this, nestedWorkUnit, second);
}
public AuditWorkUnit merge(DelWorkUnit second) {
return second;
}
public AuditWorkUnit merge(CollectionChangeWorkUnit second) {
return this;
}
public AuditWorkUnit merge(FakeBidirectionalRelationWorkUnit second) {
// First merging the nested work units.
AuditWorkUnit mergedNested = second.getNestedWorkUnit().dispatch(nestedWorkUnit);
// Now merging the fake relation changes from both work units.
Map secondFakeRelationChanges = second.getFakeRelationChanges();
Map mergedFakeRelationChanges = new HashMap();
Set allPropertyNames = new HashSet(fakeRelationChanges.keySet());
allPropertyNames.addAll(secondFakeRelationChanges.keySet());
for (String propertyName : allPropertyNames) {
mergedFakeRelationChanges.put(propertyName,
FakeRelationChange.merge(
fakeRelationChanges.get(propertyName),
secondFakeRelationChanges.get(propertyName)));
}
return new FakeBidirectionalRelationWorkUnit(this, mergedFakeRelationChanges, mergedNested);
}
public AuditWorkUnit dispatch(WorkUnitMergeVisitor first) {
return first.merge(this);
}
public static AuditWorkUnit merge(FakeBidirectionalRelationWorkUnit frwu, AuditWorkUnit nestedFirst,
AuditWorkUnit nestedSecond) {
AuditWorkUnit nestedMerged = nestedSecond.dispatch(nestedFirst);
// Creating a new fake relation work unit with the nested merged data
return new FakeBidirectionalRelationWorkUnit(frwu, nestedMerged);
}
/**
* Describes a change to a single fake bidirectional relation.
*/
private static class FakeRelationChange {
private final Object owningEntity;
private final RelationDescription rd;
private final RevisionType revisionType;
private final Object index;
public FakeRelationChange(Object owningEntity, RelationDescription rd, RevisionType revisionType,
Object index) {
this.owningEntity = owningEntity;
this.rd = rd;
this.revisionType = revisionType;
this.index = index;
}
public RevisionType getRevisionType() {
return revisionType;
}
public void generateData(SessionImplementor sessionImplementor, Map data) {
// If the revision type is "DEL", it means that the object is removed from the collection. Then the
// new owner will in fact be null.
rd.getFakeBidirectionalRelationMapper().mapToMapFromEntity(sessionImplementor, data,
revisionType == RevisionType.DEL ? null : owningEntity, null);
rd.getFakeBidirectionalRelationMapper().mapModifiedFlagsToMapFromEntity(sessionImplementor, data,
revisionType == RevisionType.DEL ? null : owningEntity, null);
// Also mapping the index, if the collection is indexed.
if (rd.getFakeBidirectionalRelationIndexMapper() != null) {
rd.getFakeBidirectionalRelationIndexMapper().mapToMapFromEntity(sessionImplementor, data,
revisionType == RevisionType.DEL ? null : index, null);
rd.getFakeBidirectionalRelationIndexMapper().mapModifiedFlagsToMapFromEntity(sessionImplementor, data,
revisionType == RevisionType.DEL ? null : index, null);
}
}
public static FakeRelationChange merge(FakeRelationChange first, FakeRelationChange second) {
if (first == null) { return second; }
if (second == null) { return first; }
/*
* The merging rules are the following (revision types of the first and second changes):
* - DEL, DEL - return any (the work units are the same)
* - DEL, ADD - return ADD (points to new owner)
* - ADD, DEL - return ADD (points to new owner)
* - ADD, ADD - return second (points to newer owner)
*/
if (first.getRevisionType() == RevisionType.DEL || second.getRevisionType() == RevisionType.ADD) {
return second;
} else {
return first;
}
}
}
}