update classes

src/oram/Bucket.java

@@ -1,24 +1,44 @@
 package oram;
 
 public class Bucket {
-	private Tree tree;
+	private int tupleBytes;
 	private Tuple[] tuples;
 
-	public Bucket(Tree tree, Tuple[] tuples) {
-		this.tree = tree;
-		this.tuples = tuples;
+	public Bucket(int numTuples, int tb) {
+		tupleBytes = tb;
+		tuples = new Tuple[numTuples];
+	}
+
+	public Bucket(Tuple[] ts) {
+		tupleBytes = ts[0].getNumBytes();
+		tuples = ts;
+	}
+
+	public int getNumTuples() {
+		return tuples.length;
+	}
+
+	public int getTupleBytes() {
+		return tupleBytes;
 	}
 
 	public Tuple[] getTuples() {
 		return tuples;
 	}
 
-	public Tuple getTupleAt(int i) {
+	public Tuple getTuple(int i) {
 		return tuples[i];
 	}
 
+	public void setTuples(Tuple[] tuples) {
+		this.tuples = tuples;
+	}
+
+	public void setTuple(int i, Tuple tuple) {
+		tuples[i] = tuple;
+	}
+
 	public byte[] toByteArray() {
-		int tupleBytes = tree.getTupleBytes();
 		byte[] bucket = new byte[tupleBytes * tuples.length];
 		for (int i = 0; i < tuples.length; i++) {
 			byte[] tuple = tuples[i].toByteArray();

src/oram/Metadata.java

@@ -119,7 +119,7 @@ public class Metadata {
 			numBuckets[i] = (long) Math.pow(2, lBits[i] + 1) - 1;
 			if (i == 0) {
 				tupleBytes[i] = aBytes[i];
-				stashSizes[i] = 0;
+				stashSizes[i] = 1;
 				treeBytes[i] = tupleBytes[i];
 			} else {
 				tupleBytes[i] = 1 + nBytes[i] + lBytes[i] + aBytes[i];

src/oram/Tree.java

@@ -22,21 +22,24 @@ public class Tree {
 
 	private Array64<Bucket> buckets;
 
-	public Tree(int i, Metadata md) {
-		treeIndex = i;
+	public Tree(int index, Metadata md) {
+		treeIndex = index;
 		w = md.getW();
-		stashSize = md.getStashSizeOfTree(i);
-		nBits = md.getNBitsOfTree(i);
-		lBits = md.getLBitsOfTree(i);
-		aBits = md.getABitsOfTree(i);
-		nBytes = md.getNBytesOfTree(i);
-		lBytes = md.getLBytesOfTree(i);
-		aBytes = md.getABytesOfTree(i);
-		tupleBytes = md.getTupleBytesOfTree(i);
-		numBuckets = md.getNumBucketsOfTree(i);
+		stashSize = md.getStashSizeOfTree(treeIndex);
+		nBits = md.getNBitsOfTree(treeIndex);
+		lBits = md.getLBitsOfTree(treeIndex);
+		aBits = md.getABitsOfTree(treeIndex);
+		nBytes = md.getNBytesOfTree(treeIndex);
+		lBytes = md.getLBytesOfTree(treeIndex);
+		aBytes = md.getABytesOfTree(treeIndex);
+		tupleBytes = md.getTupleBytesOfTree(treeIndex);
+		numBuckets = md.getNumBucketsOfTree(treeIndex);
 		d = lBits + 1;
 
 		buckets = new Array64<Bucket>(numBuckets);
+		buckets.set(0, new Bucket(stashSize, tupleBytes));
+		for (int i = 1; i < numBuckets; i++)
+			buckets.set(i, new Bucket(w, tupleBytes));
 	}
 
 	public int getTreeIndex() {

src/oram/Tuple.java

@@ -3,18 +3,32 @@ package oram;
 import java.math.BigInteger;
 
 public class Tuple {
+	private int numBytes;
 	private byte[] F;
 	private byte[] N;
 	private byte[] L;
 	private byte[] A;
 
+	public Tuple(int fs, int ns, int ls, int as) {
+		numBytes = fs + ns + ls + as;
+		F = new byte[fs];
+		N = new byte[ns];
+		L = new byte[ls];
+		A = new byte[as];
+	}
+
 	public Tuple(byte[] f, byte[] n, byte[] l, byte[] a) {
+		numBytes = f.length + n.length + l.length + a.length;
 		F = f.clone();
 		N = n.clone();
 		L = l.clone();
 		A = a.clone();
 	}
 
+	public int getNumBytes() {
+		return numBytes;
+	}
+
 	public byte[] getF() {
 		return F;
 	}
@@ -32,7 +46,7 @@ public class Tuple {
 	}
 
 	public byte[] toByteArray() {
-		byte[] tuple = new byte[F.length + N.length + L.length + A.length];
+		byte[] tuple = new byte[numBytes];
 		int offset = 0;
 		System.arraycopy(F, 0, tuple, offset, F.length);
 		offset += F.length;