diff --git a/src/main/java/Main.java b/src/main/java/Main.java
index 2d7e935..fb8c9f1 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/Main.java
@@ -23,7 +23,7 @@
         List<Relation> relations = new ArrayList<>();
 //		Relation transferRelation = new Relation(company, customer, MultiplicityValue.OneToOne);
 		Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToMany);
-		DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PUSH);
+		DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PULL);
 		
 		DataTransferDesign design;
 		try {
diff --git a/src/main/java/designPatternExtensions/designPattern/Strategy.java b/src/main/java/designPatternExtensions/designPattern/Strategy.java
index 56ffed2..fea5abf 100644
--- a/src/main/java/designPatternExtensions/designPattern/Strategy.java
+++ b/src/main/java/designPatternExtensions/designPattern/Strategy.java
@@ -16,7 +16,7 @@
     public DataTransferDesign create() throws IllegalRelationException {
         DataTransferDesign design = ModelLoader.load("models/designPattern/Strategy.Json");
         ObjectNode dragonSlayer     = design.getTransferContexts().getFirst().getSrcFirstResource();
-        ObjectNode concreteStrategy = (ObjectNode) design.getTransferContexts().getFirst().getDstResource().get(0).getDestination();
+        ObjectNode concreteStrategy = (ObjectNode) design.getTransferContexts().getFirst().getDstResource().getEdges().get(0).getDestination();
 
         DependencyInversion di = new DependencyInversion(
                 concreteStrategy, new InterfaceNode(concreteStrategy, "DragonSlayingStrategy"));
diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java
index 9bfe279..32488cf 100644
--- a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java
+++ b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java
@@ -49,20 +49,20 @@
         return transferRelation.isFlat();
     }
 
-    public List<ReferenceEdge> getSrcResource() {
-        return transferRelation.getSrcResource();
+    public ObjectHierarchy getSrcResource() {
+        return transferRelation.getSrcObjectHierarchy();
     }
 
-    public List<ReferenceEdge> getDstResource() {
-        return transferRelation.getDstResource();
+    public ObjectHierarchy getDstResource() {
+        return transferRelation.getDstObjectHierarchy();
     }
 
     public ObjectNode getSrcFirstResource() {
-        return transferRelation.getSrcFirstResource();
+        return transferRelation.getSrcTopObject();
     }
 
     public ObjectNode getDstFirstResource() {
-        return transferRelation.getDstFirstResource();
+        return transferRelation.getDstTopObject();
     }
 
 
diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java
index 9aa7fc8..312ce3b 100644
--- a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java
+++ b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java
@@ -140,36 +140,36 @@
 			return prevReference;
 		}
 		boolean toOne = true;	// potential multiplicity
-		List<ReferenceEdge> srcResource = new ArrayList<>();
-		List<ReferenceEdge> dstResource = new ArrayList<>();
+		ObjectHierarchy srcHierarchy = null;
+		ObjectHierarchy dstHierarchy = null;
 		List<Relation> allRelations = new ArrayList<>(transferContext.getRelations());
 		allRelations.add(transferContext.getTransferRelation());
 		for (Relation relation: allRelations) {
-			List<ReferenceEdge> newSrcResource = null;
-			List<ReferenceEdge> newDstResource = null;
+			ObjectHierarchy newSrcHierarchy = null;
+			ObjectHierarchy newDstHierarchy = null;
 			if (transferStyle == PushPullValue.PUSH) {
-				newSrcResource = relation.getSrcResource();
-				newDstResource = relation.getDstResource();
+				newSrcHierarchy = relation.getSrcObjectHierarchy();
+				newDstHierarchy = relation.getDstObjectHierarchy();
 			} else {
-				newSrcResource = relation.getDstResource();
-				newDstResource = relation.getSrcResource();
+				newSrcHierarchy = relation.getDstObjectHierarchy();
+				newDstHierarchy = relation.getSrcObjectHierarchy();
 			}
-			if (dstResource.size() < newDstResource.size() || srcResource.size() < newSrcResource.size()) {
+			if ((dstHierarchy == null || dstHierarchy.getDepth() < newDstHierarchy.getDepth()) || (srcHierarchy == null || srcHierarchy.getDepth() < newSrcHierarchy.getDepth())) {
 				List<ReferenceEdge> oneDestination = new ArrayList<>();
 				List<ReferenceEdge> manyDestinations = new ArrayList<>();
-				for (int i = 0; i < newDstResource.size(); i++) {
-					if (i < dstResource.size()) {
-						if (!dstResource.get(i).equals(newDstResource.get(i))) {
+				for (int i = 0; i < newDstHierarchy.getDepth(); i++) {
+					if (dstHierarchy != null && i < dstHierarchy.getDepth()) {
+						if (!dstHierarchy.getEdge(i).equals(newDstHierarchy.getEdge(i))) {
 							throw new IllegalRelationException();
 						}
 					} else {
-						if (newDstResource.get(i).toMany()) {
+						if (newDstHierarchy.getEdge(i).toMany()) {
 							toOne = false;
 						}
 						if (toOne) {
-							oneDestination.add(newDstResource.get(i));
+							oneDestination.add(newDstHierarchy.getEdge(i));
 						} else {
-							manyDestinations.add(newDstResource.get(i));
+							manyDestinations.add(newDstHierarchy.getEdge(i));
 						}
 					}
 				}
@@ -184,10 +184,10 @@
 					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)) {
+				for (int i = 0; i < newSrcHierarchy.getDepth(); i++) {
+					ReferenceEdge srcEdge = newSrcHierarchy.getEdge(i);
+					if (srcHierarchy != null && i < srcHierarchy.getDepth()) {
+						if (!srcHierarchy.getEdge(i).equals(srcEdge)) {
 							throw new IllegalRelationException();
 						}
 					} else {
@@ -264,8 +264,8 @@
 			} else {
 				throw new IllegalRelationException();
 			}
-			srcResource = newSrcResource;
-			dstResource = newDstResource;
+			srcHierarchy = newSrcHierarchy;
+			dstHierarchy = newDstHierarchy;
 		}
 		return prevReference;
 	}
diff --git a/src/main/java/models/objectOrientedTransfer/ObjectHierarchy.java b/src/main/java/models/objectOrientedTransfer/ObjectHierarchy.java
new file mode 100644
index 0000000..cf8e86b
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/ObjectHierarchy.java
@@ -0,0 +1,42 @@
+package models.objectOrientedTransfer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ObjectHierarchy {
+    private ObjectNode top;
+    private List<ReferenceEdge> edges;
+    private boolean isFlat = false;
+
+    public ObjectHierarchy(ObjectNode top) {
+        this.top = top;
+        this.edges = new ArrayList<>();
+        this.isFlat = true;
+    }
+
+    public ObjectHierarchy(List<ReferenceEdge> edges) {
+        this.top = (ObjectNode) edges.getFirst().getSource();
+        this.edges = edges;
+        this.isFlat = false;
+    }
+
+    public ObjectNode getTop() {
+        return top;
+    }
+
+    public List<ReferenceEdge> getEdges() {
+        return edges;
+    }
+
+    public boolean isFlat() {
+        return isFlat;
+    }
+
+    public int getDepth() {
+        return edges.size();
+    }
+
+    public ReferenceEdge getEdge(int index) {
+        return edges.get(index);
+    }
+}
diff --git a/src/main/java/models/objectOrientedTransfer/Relation.java b/src/main/java/models/objectOrientedTransfer/Relation.java
index c0100f1..dd21789 100644
--- a/src/main/java/models/objectOrientedTransfer/Relation.java
+++ b/src/main/java/models/objectOrientedTransfer/Relation.java
@@ -1,45 +1,38 @@
 package models.objectOrientedTransfer;
 
-import java.util.ArrayList;
 import java.util.List;
 
 public class Relation {
-	private List<ReferenceEdge> srcResource;
-	private List<ReferenceEdge> dstResource;
+	private ObjectHierarchy srcObjectHierarchy;
+	private ObjectHierarchy dstObjectHierarchy;
 	private MultiplicityValue multiplicity;
 	private boolean isFlat = false;
-	private ObjectNode srcResourceNode;
-	private ObjectNode dstResourceNode;
 
-	public Relation(List<ReferenceEdge> srcResource, List<ReferenceEdge> dstResource, MultiplicityValue multiplicity) {
+	public Relation(List<ReferenceEdge> srcObjectHierarchy, List<ReferenceEdge> dstObjectHierarchy, MultiplicityValue multiplicity) {
 		isFlat = false;
-		this.srcResource = srcResource;
-		this.dstResource = dstResource;
+		this.srcObjectHierarchy = new ObjectHierarchy(srcObjectHierarchy);
+		this.dstObjectHierarchy = new ObjectHierarchy(dstObjectHierarchy);
 		this.multiplicity = multiplicity;
 	}
 
-	public Relation(ObjectNode srcResourceNode, List<ReferenceEdge> dstResource, MultiplicityValue multiplicity) {
+	public Relation(ObjectNode srcObjectNode, List<ReferenceEdge> dstObjectHierarchy, MultiplicityValue multiplicity) {
 		isFlat = false;
-		this.srcResource = new ArrayList<>();
-		this.dstResource = dstResource;
-		this.srcResourceNode = srcResourceNode;
+		this.srcObjectHierarchy = new ObjectHierarchy(srcObjectNode);
+		this.dstObjectHierarchy = new ObjectHierarchy(dstObjectHierarchy);
 		this.multiplicity = multiplicity;
 	}
 
-	public Relation(List<ReferenceEdge> srcResource, ObjectNode dstResourceNode, MultiplicityValue multiplicity) {
+	public Relation(List<ReferenceEdge> srcObjectHierarchy, ObjectNode dstObjectNode, MultiplicityValue multiplicity) {
 		isFlat = false;
-		this.srcResource = srcResource;
-		this.dstResource = new ArrayList<>();
-		this.dstResourceNode = dstResourceNode;
+		this.srcObjectHierarchy = new ObjectHierarchy(srcObjectHierarchy);
+		this.dstObjectHierarchy = new ObjectHierarchy(dstObjectNode);
 		this.multiplicity = multiplicity;
 	}
 
-	public Relation(ObjectNode srcResourceNode, ObjectNode dstResourceNode, MultiplicityValue multiplicity) {
+	public Relation(ObjectNode srcObjectNode, ObjectNode dstObjectNode, MultiplicityValue multiplicity) {
 		this.isFlat = true;
-		this.srcResource = new ArrayList<>();
-		this.dstResource = new ArrayList<>();
-		this.srcResourceNode = srcResourceNode;
-		this.dstResourceNode = dstResourceNode;
+		this.srcObjectHierarchy = new ObjectHierarchy(srcObjectNode);
+		this.dstObjectHierarchy = new ObjectHierarchy(dstObjectNode);
 		this.multiplicity = multiplicity;
 	}
 	
@@ -47,26 +40,20 @@
 		return isFlat;
 	}
 
-	public List<ReferenceEdge> getSrcResource() {
-		return srcResource;
+	public ObjectHierarchy getSrcObjectHierarchy() {
+		return srcObjectHierarchy;
 	}
 
-	public List<ReferenceEdge> getDstResource() {
-		return dstResource;
+	public ObjectHierarchy getDstObjectHierarchy() {
+		return dstObjectHierarchy;
 	}
 
-	public ObjectNode getSrcFirstResource() {
-		if (isFlat) {
-			return srcResourceNode;
-		}
-		return (ObjectNode) srcResource.getFirst().getSource();
+	public ObjectNode getSrcTopObject() {
+		return srcObjectHierarchy.getTop();
 	}
 
-	public ObjectNode getDstFirstResource() {
-		if (isFlat) {
-			return dstResourceNode;
-		}
-		return (ObjectNode) dstResource.getFirst().getSource();
+	public ObjectNode getDstTopObject() {
+		return dstObjectHierarchy.getTop();
 	}
 
 	public MultiplicityValue getMultiplicity() {