diff --git a/src/main/java/models/objectOrientedTransfer/AtomicDelta.java b/src/main/java/models/objectOrientedTransfer/AtomicDelta.java deleted file mode 100644 index 8ade396..0000000 --- a/src/main/java/models/objectOrientedTransfer/AtomicDelta.java +++ /dev/null @@ -1,48 +0,0 @@ -package models.objectOrientedTransfer; - -import java.util.List; - -public class AtomicDelta { - private ObjectNode coordinator; - private List pullEdges; - private List pushEdges; - private StatefulObjectNode dataType; - private String dataName; - - public AtomicDelta(ObjectNode coordinator, List pullEdges, List pushEdges, - StatefulObjectNode dataType, String dataName) { - this.coordinator = coordinator; - this.pullEdges = pullEdges; - this.pushEdges = pushEdges; - this.dataType = dataType; - this.dataName = dataName; - } - - public ObjectNode getCoordinator() { - return coordinator; - } - - public List getPullEdges() { - return pullEdges; - } - - public List getPushEdges() { - return pushEdges; - } - - public StatefulObjectNode getDataType() { - return dataType; - } - - public String getDataName() { - return dataName; - } - - public boolean isPullTransfer() { - return (pushEdges == null || pushEdges.isEmpty()); - } - - public AtomicDelta copy() { - return new AtomicDelta(coordinator, pullEdges, pushEdges, dataType, dataName); - } -} diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java index bb3163f..611fcfe 100644 --- a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java +++ b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java @@ -4,7 +4,6 @@ /** * The reference context and properties of specific data transfer. - * The full context of data transfer designs containing delta algebra and dependency injection. * * @author Nitta * @@ -12,12 +11,12 @@ public class DataTransferContext { private List relations; private Relation transferRelation; - private StatefulObjectNode dataType; + private ObjectNode dataType; private String dataName; private PushPullValue transferStyle; public DataTransferContext(List relations, Relation transferRelation, - StatefulObjectNode dataType, String dataName, PushPullValue transferStyle, MultiplicityValue transferMultiplicity) { + ObjectNode dataType, String dataName, PushPullValue transferStyle, MultiplicityValue transferMultiplicity) { this.relations = relations; this.transferRelation = transferRelation; this.dataType = dataType; @@ -29,6 +28,10 @@ return relations; } + public Relation getTransferRelation() { + return transferRelation; + } + public List getSrcResource() { return transferRelation.getSrcResource(); } @@ -41,7 +44,7 @@ return transferRelation.getMultiplicity(); } - public StatefulObjectNode getDataType() { + public ObjectNode getDataType() { return dataType; } diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java index f5af3b9..b66a73f 100644 --- a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java +++ b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java @@ -1,17 +1,228 @@ package models.objectOrientedTransfer; +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +/** + * The final data transfer designs containing delta algebra and dependency injection. + * + * @author Nitta + * + */ public class DataTransferDesign { private DataTransferContext transferContext; private DeltaComplex deltaComplex; - public DataTransferDesign(DataTransferContext transferContext) { + public DataTransferDesign(DataTransferContext transferContext) throws IllegalRelationException { this.transferContext = transferContext; this.deltaComplex = createDefaultDeltaComlex(transferContext); } - public DeltaComplex createDefaultDeltaComlex(DataTransferContext transferContext) { + public DeltaComplex createDefaultDeltaComlex(DataTransferContext transferContext) throws IllegalRelationException { + if (transferContext.getTransferStyle() == PushPullValue.PUSH) { + // PUSH transfer + if (transferContext.getTransferMultiplicity() == MultiplicityValue.ManyToOne + || transferContext.getTransferMultiplicity() == MultiplicityValue.OneToOne) { + // Simple PUSH + + // Construct all deltas. + Stack deltaStack = new Stack<>(); + ReferenceEdge bottomReference = constructDefaultDeltas(transferContext, deltaStack); + Delta dataTransferDelta = deltaStack.pop(); + if (dataTransferDelta != null) { + // Add the data transfer delta. + ObjectNode srcObj = (ObjectNode) bottomReference.getSource(); + ObjectNode dstObj = (ObjectNode) transferContext.getDataType(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + ReferenceEdge dataEdge = new ReferenceEdge(srcObj, dstObj, dataName); + dataTransferDelta = dataTransferDelta.combine(new PrimitivePullPushDelta(dataEdge, bottomReference, dataName)); // PUSH data transfer + DeltaComplex deltaComplex = new DeltaComplex(dataTransferDelta); + + // Add initialization deltas. + while (!deltaStack.isEmpty()) { + deltaComplex.attach(deltaStack.pop()); + } + return deltaComplex; + } + } else { + // Broadcasting + } + } else { + if (transferContext.getTransferMultiplicity() == MultiplicityValue.ManyToOne + || transferContext.getTransferMultiplicity() == MultiplicityValue.OneToOne) { + // Simple PULL + + // Construct all deltas. + Stack deltaStack = new Stack<>(); + ReferenceEdge bottomReference = constructDefaultDeltas(transferContext, deltaStack); + Delta dataTransferDelta = deltaStack.pop(); + if (dataTransferDelta != null) { + // Add the data transfer delta. + ObjectNode srcObj = (ObjectNode) bottomReference.getDestination(); + ObjectNode dstObj = (ObjectNode) transferContext.getDataType(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + ReferenceEdge dataEdge = new ReferenceEdge(srcObj, dstObj, dataName); + dataTransferDelta = dataTransferDelta.combine(new PrimitivePullDelta(bottomReference, dataEdge, dataName)); // PULL data transfer + DeltaComplex deltaComplex = new DeltaComplex(dataTransferDelta); + + // Add initialization deltas. + while (!deltaStack.isEmpty()) { + deltaComplex.attach(deltaStack.pop()); + } + return deltaComplex; + } + } else { + // Data collecting + } + } return null; } + + private ReferenceEdge constructDefaultDeltas(DataTransferContext transferContext, Stack deltaStack) throws IllegalRelationException { + PushPullValue transferStyle = transferContext.getTransferStyle(); + ObjectNode srcObj = null; + ObjectNode dstObj = null; + if (transferStyle == PushPullValue.PUSH) { + srcObj = (ObjectNode) transferContext.getSrcResource().getFirst().getSource(); + dstObj = (ObjectNode) transferContext.getDstResource().getFirst().getSource(); + } else { + srcObj = (ObjectNode) transferContext.getDstResource().getFirst().getSource(); + dstObj = (ObjectNode) transferContext.getSrcResource().getFirst().getSource(); + } + String refName = dstObj.getName().substring(0, 1).toLowerCase() + dstObj.getName().substring(1); + ReferenceEdge prevReference = new ReferenceEdge(srcObj, dstObj, refName); + boolean toOne = true; // potential multiplicity + List srcResource = new ArrayList<>(); + List dstResource = new ArrayList<>(); + List allRelations = new ArrayList<>(transferContext.getRelations()); + allRelations.add(transferContext.getTransferRelation()); + for (Relation relation: allRelations) { + List newSrcResource = null; + List newDstResource = null; + if (transferStyle == PushPullValue.PUSH) { + newSrcResource = relation.getSrcResource(); + newDstResource = relation.getDstResource(); + } else { + newSrcResource = relation.getDstResource(); + newDstResource = relation.getSrcResource(); + } + if (dstResource.size() < newDstResource.size()) { + List oneDestination = new ArrayList<>(); + List manyDestinations = new ArrayList<>(); + for (int i = 0; i < newDstResource.size(); i++) { + if (i < dstResource.size()) { + if (!dstResource.get(i).equals(newDstResource.get(i))) { + throw new IllegalRelationException(); + } + } else { + if (newDstResource.get(i).getMultiplicity() == MultiplicityValue.OneToMany) { + toOne = false; + } + if (toOne) { + oneDestination.add(newDstResource.get(i)); + } else { + manyDestinations.add(newDstResource.get(i)); + } + } + } + if (!toOne && + ((transferStyle == PushPullValue.PUSH && (relation.getMultiplicity() == MultiplicityValue.ManyToOne || relation.getMultiplicity() == MultiplicityValue.OneToOne)) + || (transferStyle != PushPullValue.PUSH && (relation.getMultiplicity() == MultiplicityValue.OneToMany || relation.getMultiplicity() == MultiplicityValue.OneToOne)))) { + // If the specified multiplicity of destination objects does not match to their potential multiplicity, + // then the reference to select one destination object from potential multiple objects is needed. + + // 1) Create container passing deltas. + List primitiveDeltaList = new ArrayList<>(); + for (ReferenceEdge dstEdge: oneDestination) { + srcObj = (ObjectNode) prevReference.getSource(); + dstObj = (ObjectNode) dstEdge.getDestination(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + primitiveDeltaList.add(new PrimitivePullDelta(prevReference, dstEdge, dataName)); + prevReference = new ReferenceEdge(srcObj, dstObj, dataName); + } + for (int i = 0; i < newSrcResource.size(); i++) { + ReferenceEdge srcEdge = newSrcResource.get(i); + if (i < srcResource.size()) { + if (!srcResource.get(i).equals(srcEdge)) { + throw new IllegalRelationException(); + } + } else { + srcObj = (ObjectNode) srcEdge.getDestination(); + dstObj = (ObjectNode) prevReference.getDestination(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + primitiveDeltaList.add(new PrimitivePullPushDelta(prevReference, srcEdge, dataName)); + Delta delta = null; + for (PrimitiveDelta primDelta: primitiveDeltaList) { + if (delta == null) { + delta = new Delta(primDelta); + } else { + delta = new Delta(primDelta, delta); + } + } + deltaStack.push(delta); // add a container passing delta + primitiveDeltaList.clear(); + prevReference = new ReferenceEdge(srcObj, dstObj, dataName); + } + } + + // 2) Create a component identifying delta. + PrimitiveDelta componentSelectingDelta = null; + for (ReferenceEdge dstEdge: manyDestinations) { + if (componentSelectingDelta == null) { + srcObj = (ObjectNode) prevReference.getSource(); + dstObj = (ObjectNode) dstEdge.getDestination(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + componentSelectingDelta = new PrimitivePullDelta(prevReference, dstEdge, dataName); + primitiveDeltaList.add(componentSelectingDelta); + Delta delta = null; + for (PrimitiveDelta primDelta: primitiveDeltaList) { + if (delta == null) { + delta = new Delta(primDelta); + } else { + delta = new Delta(primDelta, delta); + } + } + deltaStack.push(delta); // add a component identifying delta + primitiveDeltaList.clear(); + prevReference = new ReferenceEdge(srcObj, dstObj, dataName); + } else { + srcObj = (ObjectNode) prevReference.getSource(); + dstObj = (ObjectNode) dstEdge.getDestination(); + String dataName = dstObj.getName(); + dataName = dataName.substring(0, 1).toLowerCase() + dataName.substring(1); + primitiveDeltaList.add(new PrimitivePullDelta(prevReference, dstEdge, dataName)); + prevReference = new ReferenceEdge(srcObj, dstObj, dataName); + } + } + + // 3) Create a component obtaining delta. + if (primitiveDeltaList.size() > 0) { + Delta delta = null; + for (PrimitiveDelta primDelta: primitiveDeltaList) { + if (delta == null) { + delta = new Delta(primDelta); + } else { + delta = new Delta(primDelta, delta); + } + } + deltaStack.push(delta); // add a component obtaining delta + } + toOne = true; + } + } else { + throw new IllegalRelationException(); + } + srcResource = newSrcResource; + dstResource = newDstResource; + } + return prevReference; + } public DeltaComplex getDeltaComplex() { return deltaComplex; diff --git a/src/main/java/models/objectOrientedTransfer/Delta.java b/src/main/java/models/objectOrientedTransfer/Delta.java index bea3e77..08b0c0e 100644 --- a/src/main/java/models/objectOrientedTransfer/Delta.java +++ b/src/main/java/models/objectOrientedTransfer/Delta.java @@ -11,14 +11,14 @@ * */ public class Delta { - private AtomicDelta bottomDelta = null; + private PrimitiveDelta bottomDelta = null; private Delta subDelta = null; - public Delta(AtomicDelta delta) { + public Delta(PrimitiveDelta delta) { bottomDelta = delta; } - public Delta(AtomicDelta bottomDelta, Delta subDelta) { + public Delta(PrimitiveDelta bottomDelta, Delta subDelta) { this.bottomDelta = bottomDelta; this.subDelta = subDelta; } @@ -42,25 +42,25 @@ return pushEdges; } - public Delta combine(AtomicDelta delta) { + public Delta combine(PrimitiveDelta delta) { return new Delta(delta, this); } public Delta combine(Delta delta) { Delta preDelta = this.copy(); - for (AtomicDelta atomicDelta: delta.split()) { + for (PrimitiveDelta atomicDelta: delta.split()) { preDelta = preDelta.combine(atomicDelta); } return preDelta; } - public List split() { + public List split() { if (subDelta == null) { - List atomicDeltaSequence = new ArrayList<>(); + List atomicDeltaSequence = new ArrayList<>(); atomicDeltaSequence.add(bottomDelta); return atomicDeltaSequence; } - List atomicDeltaSequence = subDelta.split(); + List atomicDeltaSequence = subDelta.split(); atomicDeltaSequence.add(bottomDelta); return atomicDeltaSequence; } diff --git a/src/main/java/models/objectOrientedTransfer/IllegalRelationException.java b/src/main/java/models/objectOrientedTransfer/IllegalRelationException.java new file mode 100644 index 0000000..0813b4e --- /dev/null +++ b/src/main/java/models/objectOrientedTransfer/IllegalRelationException.java @@ -0,0 +1,5 @@ +package models.objectOrientedTransfer; + +public class IllegalRelationException extends Exception { + +} diff --git a/src/main/java/models/objectOrientedTransfer/PrimitiveDelta.java b/src/main/java/models/objectOrientedTransfer/PrimitiveDelta.java new file mode 100644 index 0000000..8b0c645 --- /dev/null +++ b/src/main/java/models/objectOrientedTransfer/PrimitiveDelta.java @@ -0,0 +1,25 @@ +package models.objectOrientedTransfer; + +import java.util.List; + +abstract public class PrimitiveDelta { + protected String dataName; + + public PrimitiveDelta(String dataName) { + this.dataName = dataName; + } + + abstract public ObjectNode getCoordinator(); + + abstract public List getPullEdges(); + + abstract public List getPushEdges(); + + abstract public ObjectNode getDataType(); + + public String getDataName() { + return dataName; + } + + abstract public PrimitiveDelta copy(); +} diff --git a/src/main/java/models/objectOrientedTransfer/PrimitivePullDelta.java b/src/main/java/models/objectOrientedTransfer/PrimitivePullDelta.java new file mode 100644 index 0000000..7c68e94 --- /dev/null +++ b/src/main/java/models/objectOrientedTransfer/PrimitivePullDelta.java @@ -0,0 +1,44 @@ +package models.objectOrientedTransfer; + +import java.util.ArrayList; +import java.util.List; + +public class PrimitivePullDelta extends PrimitiveDelta { + private ReferenceEdge pullEdge1 = null; + private ReferenceEdge pullEdge2 = null; + + public PrimitivePullDelta(ReferenceEdge pullEdge1, ReferenceEdge pullEdge2, String dataName) { + super(dataName); + this.pullEdge1 = pullEdge1; + this.pullEdge2 = pullEdge2; + } + + @Override + public ObjectNode getCoordinator() { + return (ObjectNode) pullEdge1.getSource(); + } + + @Override + public List getPullEdges() { + List pullEdges = new ArrayList<>(); + pullEdges.add(pullEdge1); + pullEdges.add(pullEdge2); + return pullEdges; + } + + @Override + public List getPushEdges() { + List pushEdges = new ArrayList<>(); + return pushEdges; + } + + @Override + public ObjectNode getDataType() { + return (ObjectNode) pullEdge2.getDestination(); + } + + public PrimitivePullDelta copy() { + return new PrimitivePullDelta(pullEdge1, pullEdge2, dataName); + } + +} diff --git a/src/main/java/models/objectOrientedTransfer/PrimitivePullPushDelta.java b/src/main/java/models/objectOrientedTransfer/PrimitivePullPushDelta.java new file mode 100644 index 0000000..8f210ed --- /dev/null +++ b/src/main/java/models/objectOrientedTransfer/PrimitivePullPushDelta.java @@ -0,0 +1,44 @@ +package models.objectOrientedTransfer; + +import java.util.ArrayList; +import java.util.List; + +public class PrimitivePullPushDelta extends PrimitiveDelta { + private ReferenceEdge pullEdge = null; + private ReferenceEdge pushEdge = null; + + public PrimitivePullPushDelta(ReferenceEdge pullEdge, ReferenceEdge pushEdge, String dataName) { + super(dataName); + this.pullEdge = pullEdge; + this.pushEdge = pushEdge; + } + + @Override + public ObjectNode getCoordinator() { + return (ObjectNode) pushEdge.getSource(); + } + + @Override + public List getPullEdges() { + List pullEdges = new ArrayList<>(); + pullEdges.add(pullEdge); + return pullEdges; + } + + @Override + public List getPushEdges() { + List pushEdges = new ArrayList<>(); + pushEdges.add(pushEdge); + return pushEdges; + } + + @Override + public ObjectNode getDataType() { + return (ObjectNode) pullEdge.getDestination(); + } + + public PrimitivePullPushDelta copy() { + return new PrimitivePullPushDelta(pullEdge, pushEdge, dataName); + } + +} diff --git a/src/main/java/models/objectOrientedTransfer/PrimitivePushDelta.java b/src/main/java/models/objectOrientedTransfer/PrimitivePushDelta.java new file mode 100644 index 0000000..1fd0614 --- /dev/null +++ b/src/main/java/models/objectOrientedTransfer/PrimitivePushDelta.java @@ -0,0 +1,45 @@ +package models.objectOrientedTransfer; + +import java.util.ArrayList; +import java.util.List; + +public class PrimitivePushDelta extends PrimitiveDelta { + private ReferenceEdge pushEdge1 = null; + private ReferenceEdge pushEdge2 = null; + + public PrimitivePushDelta(ReferenceEdge pushEdge1, ReferenceEdge pushEdge2, String dataName) { + super(dataName); + this.pushEdge1 = pushEdge1; + this.pushEdge2 = pushEdge2; + } + + @Override + public ObjectNode getCoordinator() { + return (ObjectNode) pushEdge1.getSource(); + } + + @Override + public List getPullEdges() { + List pullEdges = new ArrayList<>(); + return pullEdges; + } + + @Override + public List getPushEdges() { + List pushEdges = new ArrayList<>(); + pushEdges.add(pushEdge1); + pushEdges.add(pushEdge2); + return pushEdges; + } + + @Override + public ObjectNode getDataType() { + return (ObjectNode) pushEdge1.getSource(); + } + + @Override + public PrimitivePushDelta copy() { + return new PrimitivePushDelta(pushEdge1, pushEdge2, dataName); + } + +}