diff --git a/src/main/java/models/Node.java b/src/main/java/models/Node.java
index 2eda554..5fa7a59 100644
--- a/src/main/java/models/Node.java
+++ b/src/main/java/models/Node.java
@@ -1,11 +1,12 @@
 package models;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
 public class Node implements Cloneable {
-	private Set<Edge> inEdges = null;
-	private Set<Edge> outEdges = null;
+	protected Collection<Edge> inEdges = null;
+	protected Collection<Edge> outEdges = null;
 	private NodeAttribute attribute;
 	
 	public Node() {
@@ -13,19 +14,19 @@
 		outEdges = new HashSet<>();
 	}
 	
-	public Set<Edge> getInEdges() {
+	public Collection<Edge> getInEdges() {
 		return inEdges;
 	}
 	
-	public void setInEdges(Set<Edge> inEdges) {
+	public void setInEdges(Collection<Edge> inEdges) {
 		this.inEdges = inEdges;
 	}
 	
-	public Set<Edge> getOutEdges() {
+	public Collection<Edge> getOutEdges() {
 		return outEdges;
 	}
 	
-	public void setOutEdges(Set<Edge> outEdges) {
+	public void setOutEdges(Collection<Edge> outEdges) {
 		this.outEdges = outEdges;
 	}
 	
diff --git a/src/main/java/models/objectOrientedTransfer/AtomicDelta.java b/src/main/java/models/objectOrientedTransfer/AtomicDelta.java
new file mode 100644
index 0000000..8ade396
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/AtomicDelta.java
@@ -0,0 +1,48 @@
+package models.objectOrientedTransfer;
+
+import java.util.List;
+
+public class AtomicDelta {
+	private ObjectNode coordinator;
+	private List<ReferenceEdge> pullEdges;
+	private List<ReferenceEdge> pushEdges;
+	private StatefulObjectNode dataType;
+	private String dataName;
+
+	public AtomicDelta(ObjectNode coordinator, List<ReferenceEdge> pullEdges, List<ReferenceEdge> 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<ReferenceEdge> getPullEdges() {
+		return pullEdges;
+	}
+
+	public List<ReferenceEdge> 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
new file mode 100644
index 0000000..e5e6ad9
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java
@@ -0,0 +1,53 @@
+package models.objectOrientedTransfer;
+
+import java.util.List;
+
+/**
+ * The reference context and properties of specific data transfer.
+ * The full context of data transfer designs containing delta algebra and dependency injection.
+ * 
+ * @author Nitta
+ *
+ */
+public class DataTransferContext {
+	private List<ReferenceEdge> srcResource;
+	private List<ReferenceEdge> dstResource;
+	private StatefulObjectNode dataType;
+	private String dataName;
+	private PushPullValue transferStyle;
+	private MultiplicityValue transferMultiplicity;
+	
+	public DataTransferContext(List<ReferenceEdge> srcResource, List<ReferenceEdge> dstResource, 
+			StatefulObjectNode dataType, String dataName, PushPullValue transferStyle, MultiplicityValue transferMultiplicity) {
+		this.srcResource = srcResource;
+		this.dstResource = dstResource;
+		this.dataType = dataType;
+		this.dataName = dataName;
+		this.transferStyle = transferStyle;
+		this.transferMultiplicity = transferMultiplicity;
+	}
+
+	public List<ReferenceEdge> getSrcResource() {
+		return srcResource;
+	}
+
+	public List<ReferenceEdge> getDstResource() {
+		return dstResource;
+	}
+
+	public StatefulObjectNode getDataType() {
+		return dataType;
+	}
+
+	public String getDataName() {
+		return dataName;
+	}
+
+	public PushPullValue getTransferStyle() {
+		return transferStyle;
+	}
+
+	public MultiplicityValue getTransferMultiplicity() {
+		return transferMultiplicity;
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/Delta.java b/src/main/java/models/objectOrientedTransfer/Delta.java
new file mode 100644
index 0000000..bea3e77
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/Delta.java
@@ -0,0 +1,71 @@
+package models.objectOrientedTransfer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A program structure related to specific data transfer.
+ * Deltas can be generated from a data transfer context.
+ * 
+ * @author Nitta
+ *
+ */
+public class Delta {
+	private AtomicDelta bottomDelta = null;
+	private Delta subDelta = null;
+	
+	public Delta(AtomicDelta delta) {
+		bottomDelta = delta;
+	}
+	
+	public Delta(AtomicDelta bottomDelta, Delta subDelta) {
+		this.bottomDelta = bottomDelta;
+		this.subDelta = subDelta;
+	}
+	
+	public ObjectNode getCoordinator() {
+		if (subDelta == null) return bottomDelta.getCoordinator();
+		return subDelta.getCoordinator();
+	}
+
+	public List<ReferenceEdge> getPullEdges() {
+		if (subDelta == null) return bottomDelta.getPullEdges();
+		List<ReferenceEdge> pullEdges = new ArrayList<>(subDelta.getPullEdges());
+		pullEdges.addAll(bottomDelta.getPullEdges());
+		return pullEdges;
+	}
+
+	public List<ReferenceEdge> getPushEdges() {
+		if (subDelta == null) return bottomDelta.getPushEdges();
+		List<ReferenceEdge> pushEdges = new ArrayList<>(subDelta.getPushEdges());
+		pushEdges.addAll(bottomDelta.getPushEdges());
+		return pushEdges;
+	}
+	
+	public Delta combine(AtomicDelta delta) {
+		return new Delta(delta, this);
+	}
+	
+	public Delta combine(Delta delta) {
+		Delta preDelta = this.copy();
+		for (AtomicDelta atomicDelta: delta.split()) {
+			preDelta = preDelta.combine(atomicDelta);
+		}
+		return preDelta;
+	}
+	
+	public List<AtomicDelta> split() {
+		if (subDelta == null) {
+			List<AtomicDelta> atomicDeltaSequence = new ArrayList<>();
+			atomicDeltaSequence.add(bottomDelta);
+			return atomicDeltaSequence;
+		}
+		List<AtomicDelta> atomicDeltaSequence = subDelta.split();
+		atomicDeltaSequence.add(bottomDelta);
+		return atomicDeltaSequence;
+	}
+	
+	public Delta copy() {
+		return new Delta(bottomDelta.copy(), subDelta.copy());
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/DeltaComplex.java b/src/main/java/models/objectOrientedTransfer/DeltaComplex.java
new file mode 100644
index 0000000..0ede815
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/DeltaComplex.java
@@ -0,0 +1,51 @@
+package models.objectOrientedTransfer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeltaComplex {
+	private Delta frontierDelta;
+	private DeltaComplex subComplex = null;
+	
+	public DeltaComplex(Delta delta) {
+		this.frontierDelta = delta;
+	}
+	
+	public DeltaComplex(Delta frontierDelta, DeltaComplex subComplex) {
+		this.frontierDelta = frontierDelta;
+		this.subComplex = subComplex;
+	}
+	
+	public void attach(Delta delta) {
+		this.subComplex = this.copy();
+		this.frontierDelta = delta;
+	}
+	
+	public List<Delta> split() {
+		if (subComplex == null) {
+			List<Delta> deltaSequence = new ArrayList<>();
+			deltaSequence.add(frontierDelta);
+			return deltaSequence;
+		}
+		List<Delta> deltaSequence = subComplex.split();
+		deltaSequence.add(0, frontierDelta);
+		return deltaSequence;
+	}
+	
+	public Delta collapse() {
+		Delta allDelta = null;
+		for (Delta delta: this.split()) {
+			if (allDelta == null) {
+				allDelta = delta;
+			} else {
+				allDelta = allDelta.combine(delta);
+			}
+		}
+		return allDelta;
+	}
+	
+	public DeltaComplex copy() {
+		DeltaComplex newComplex = new DeltaComplex(frontierDelta.copy(), subComplex.copy());
+		return newComplex;
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/MultiplicityValue.java b/src/main/java/models/objectOrientedTransfer/MultiplicityValue.java
new file mode 100644
index 0000000..2455abe
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/MultiplicityValue.java
@@ -0,0 +1,20 @@
+package models.objectOrientedTransfer;
+
+public enum MultiplicityValue {
+	OneToOne,
+	OneToMany,
+	ManyToOne;
+	
+	public String toString() {
+		switch (this) {
+		case OneToOne:
+			return "1:1";
+		case OneToMany:
+			return "1:*";
+		case ManyToOne:
+			return "*:1";
+		default:
+			return "";				
+		}
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/ObjectNode.java b/src/main/java/models/objectOrientedTransfer/ObjectNode.java
new file mode 100644
index 0000000..0ffdaa8
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/ObjectNode.java
@@ -0,0 +1,19 @@
+package models.objectOrientedTransfer;
+
+import models.Node;
+
+public class ObjectNode extends Node {
+	protected String name;
+	
+	public ObjectNode(String name) {
+		this.name = name;
+	}
+ 
+	public String getName() {
+		return name;
+	}
+ 
+	public void setName(String name) {
+		this.name = name;
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/PushPullValue.java b/src/main/java/models/objectOrientedTransfer/PushPullValue.java
new file mode 100644
index 0000000..dd1a809
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/PushPullValue.java
@@ -0,0 +1,20 @@
+package models.objectOrientedTransfer;
+
+public enum PushPullValue {
+	PULL,
+	PUSHorPULL,
+	PUSH;
+	
+	public String toString() {
+		switch (this) {
+		case PUSHorPULL:
+			return "PUSH/PULL";
+		case PUSH:
+			return "PUSH";
+		case PULL:
+			return "PULL";
+		default:
+			return "";				
+		}
+	}
+}
diff --git a/src/main/java/models/objectOrientedTransfer/ReferenceEdge.java b/src/main/java/models/objectOrientedTransfer/ReferenceEdge.java
new file mode 100644
index 0000000..7ffd092
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/ReferenceEdge.java
@@ -0,0 +1,31 @@
+package models.objectOrientedTransfer;
+
+import models.Edge;
+
+public class ReferenceEdge extends Edge {
+	protected String name;
+	protected MultiplicityValue multiplicity;
+	
+	public ReferenceEdge(ObjectNode src, ObjectNode dst, String name) {
+		super(src, dst);
+		this.name = name;
+		this.multiplicity = MultiplicityValue.OneToOne;
+	}
+	 
+	public String getName() {
+		return name;
+	}
+ 
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	public MultiplicityValue getMultiplicity() {
+		return multiplicity;
+	}
+
+	public void setMultiplicity(MultiplicityValue multiplicity) {
+		this.multiplicity = multiplicity;
+	}
+
+}
diff --git a/src/main/java/models/objectOrientedTransfer/StatefulObjectNode.java b/src/main/java/models/objectOrientedTransfer/StatefulObjectNode.java
new file mode 100644
index 0000000..8a836ba
--- /dev/null
+++ b/src/main/java/models/objectOrientedTransfer/StatefulObjectNode.java
@@ -0,0 +1,11 @@
+package models.objectOrientedTransfer;
+
+import models.algebra.Symbol.Type;
+
+public class StatefulObjectNode extends ObjectNode {
+	private Type stateType = null;
+
+	public StatefulObjectNode(String name) {
+		super(name);
+	}
+}