changed A in tuple so labels in A are also byte aligned

src/oram/Bucket.java

@@ -1,5 +1,7 @@
 package oram;
 
+import exceptions.LengthNotMatchException;
+
 public class Bucket {
 	private Tuple[] tuples;
 
@@ -11,6 +13,13 @@ public class Bucket {
 		this.tuples = tuples;
 	}
 
+	// deep copy
+	public Bucket(Bucket b) {
+		tuples = new Tuple[b.getNumTuples()];
+		for (int i = 0; i < tuples.length; i++)
+			tuples[i] = new Tuple(b.getTuple(i));
+	}
+
 	public int getNumTuples() {
 		return tuples.length;
 	}
@@ -24,6 +33,8 @@ public class Bucket {
 	}
 
 	public void setTuples(Tuple[] tuples) {
+		if (this.tuples.length != tuples.length)
+			throw new LengthNotMatchException(this.tuples.length + " != " + tuples.length);
 		this.tuples = tuples;
 	}
 

src/oram/Forest.java

@@ -113,11 +113,9 @@ public class Forest {
 						indexN = (int) Util.getSubBits(N[i + 1], lastNBits, 0);
 					else
 						indexN = (int) Util.getSubBits(N[i + 1], tau, 0);
-					int start = (md.getTwoTauPow() - indexN - 1) * md.getLBitsOfTree(i + 1);
-					int end = start + md.getLBitsOfTree(i + 1);
-					BigInteger newA = Util.setSubBits(new BigInteger(1, targetTuple.getA()),
-							BigInteger.valueOf(L[i + 1]), end, start);
-					targetTuple.setA(Util.rmSignBit(newA.toByteArray()));
+					int start = indexN * trees[i].getAlBytes();
+					int end = start + trees[i].getAlBytes();
+					targetTuple.setALabel(start, end, Util.rmSignBit(BigInteger.valueOf(L[i + 1]).toByteArray()));
 				}
 				// for the last tree, update the whole A field of the target
 				// tuple

src/oram/Metadata.java

@@ -33,17 +33,17 @@ public class Metadata {
 
 	private int[] nBits;
 	private int[] lBits;
-	private int[] aBits;
+	private int[] alBits;
 
 	private int[] nBytes;
 	private int[] lBytes;
+	private int[] alBytes;
 	private int[] aBytes;
 	private int[] tupleBytes;
 
 	private int[] stashSizes;
 	private long[] numBuckets;
 	private long[] treeBytes;
-	private long[] treeOffsets;
 
 	private long forestBytes;
 
@@ -85,35 +85,39 @@ public class Metadata {
 
 		lBits = new int[numTrees];
 		nBits = new int[numTrees];
-		aBits = new int[numTrees];
+		alBits = new int[numTrees];
 		lBytes = new int[numTrees];
 		nBytes = new int[numTrees];
+		alBytes = new int[numTrees];
 		aBytes = new int[numTrees];
 		tupleBytes = new int[numTrees];
 
 		stashSizes = new int[numTrees];
 		numBuckets = new long[numTrees];
-		treeOffsets = new long[numTrees];
 		treeBytes = new long[numTrees];
 
+		forestBytes = 0;
+
 		for (int i = numTrees - 1; i >= 0; i--) {
 			if (i == 0) {
 				nBits[i] = 0;
 				lBits[i] = 0;
-				aBits[i] = twoTauPow * lBits[i + 1];
+				alBits[i] = lBits[i + 1];
 			} else if (i < numTrees - 1) {
 				nBits[i] = i * tau;
 				lBits[i] = nBits[i] + 1;
-				aBits[i] = twoTauPow * lBits[i + 1];
+				alBits[i] = lBits[i + 1];
 			} else {
 				nBits[i] = addrBits;
 				lBits[i] = nBits[i] + 1;
-				aBits[i] = dBytes * 8;
+				alBits[i] = 0;
 			}
 
 			nBytes[i] = (nBits[i] + 7) / 8;
 			lBytes[i] = (lBits[i] + 7) / 8;
-			aBytes[i] = (aBits[i] + 7) / 8;
+			alBytes[i] = (alBits[i] + 7) / 8;
+			aBytes[i] = (i < numTrees - 1) ? (alBytes[i] * twoTauPow) : dBytes;
+
 			numBuckets[i] = (long) Math.pow(2, lBits[i] + 1) - 1;
 			if (i == 0) {
 				tupleBytes[i] = aBytes[i];
@@ -124,11 +128,7 @@ public class Metadata {
 				stashSizes[i] = tempStashSize;
 				treeBytes[i] = ((numBuckets[i] - 1) * w + stashSizes[i]) * tupleBytes[i];
 			}
-		}
 
-		forestBytes = 0L;
-		for (int i = 0; i < numTrees; i++) {
-			treeOffsets[i] = forestBytes;
 			forestBytes += treeBytes[i];
 		}
 	}
@@ -151,11 +151,14 @@ public class Metadata {
 			System.out.println("[Tree " + i + "]");
 			System.out.println("	nBits		-> " + nBits[i]);
 			System.out.println("	lBits		-> " + lBits[i]);
-			System.out.println("	aBits		-> " + aBits[i]);
+			System.out.println("	alBits		-> " + alBits[i]);
+			System.out.println("	nBytes		-> " + nBytes[i]);
+			System.out.println("	lBytes		-> " + lBytes[i]);
+			System.out.println("	alBytes		-> " + alBytes[i]);
+			System.out.println("	aBytes		-> " + aBytes[i]);
 			System.out.println("	tupleBytes	-> " + tupleBytes[i]);
 			System.out.println("	stashSize	-> " + stashSizes[i]);
 			System.out.println("	numBuckets	-> " + numBuckets[i]);
-			System.out.println("	treeOffset	-> " + treeOffsets[i]);
 			System.out.println("	treeBytes	-> " + treeBytes[i]);
 			System.out.println();
 		}
@@ -231,8 +234,8 @@ public class Metadata {
 		return lBits[i];
 	}
 
-	public int getABitsOfTree(int i) {
-		return aBits[i];
+	public int getAlBitsOfTree(int i) {
+		return alBits[i];
 	}
 
 	public int getNBytesOfTree(int i) {
@@ -243,6 +246,10 @@ public class Metadata {
 		return lBytes[i];
 	}
 
+	public int getAlBytesOfTree(int i) {
+		return alBytes[i];
+	}
+
 	public int getABytesOfTree(int i) {
 		return aBytes[i];
 	}
@@ -263,10 +270,6 @@ public class Metadata {
 		return treeBytes[i];
 	}
 
-	public long getTreeOffsetOfTree(int i) {
-		return treeOffsets[i];
-	}
-
 	public long getForestBytes() {
 		return forestBytes;
 	}

src/oram/Tree.java

@@ -12,9 +12,10 @@ public class Tree {
 	private int stashSize;
 	private int nBits;
 	private int lBits;
-	private int aBits;
+	private int alBits;
 	private int nBytes;
 	private int lBytes;
+	private int alBytes;
 	private int aBytes;
 	private int tupleBytes;
 	private long numBuckets;
@@ -28,9 +29,10 @@ public class Tree {
 		stashSize = md.getStashSizeOfTree(treeIndex);
 		nBits = md.getNBitsOfTree(treeIndex);
 		lBits = md.getLBitsOfTree(treeIndex);
-		aBits = md.getABitsOfTree(treeIndex);
+		alBits = md.getAlBitsOfTree(treeIndex);
 		nBytes = md.getNBytesOfTree(treeIndex);
 		lBytes = md.getLBytesOfTree(treeIndex);
+		alBytes = md.getAlBytesOfTree(treeIndex);
 		aBytes = md.getABytesOfTree(treeIndex);
 		tupleBytes = md.getTupleBytesOfTree(treeIndex);
 		numBuckets = md.getNumBucketsOfTree(treeIndex);
@@ -62,8 +64,8 @@ public class Tree {
 		return lBits;
 	}
 
-	public int getABits() {
-		return aBits;
+	public int getAlBits() {
+		return alBits;
 	}
 
 	public int getNBytes() {
@@ -74,6 +76,10 @@ public class Tree {
 		return lBytes;
 	}
 
+	public int getAlBytes() {
+		return alBytes;
+	}
+
 	public int getABytes() {
 		return aBytes;
 	}

src/oram/Tuple.java

@@ -1,32 +1,41 @@
 package oram;
 
 import java.math.BigInteger;
+import java.util.Arrays;
+
+import exceptions.LengthNotMatchException;
 
 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];
 	}
 
+	// shallow copy
 	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();
+		F = f;
+		N = n;
+		L = l;
+		A = a;
+	}
+
+	// deep copy
+	public Tuple(Tuple t) {
+		F = t.getF().clone();
+		N = t.getN().clone();
+		L = t.getL().clone();
+		A = t.getA().clone();
 	}
 
 	public int getNumBytes() {
-		return numBytes;
+		return F.length + N.length + L.length + A.length;
 	}
 
 	public byte[] getF() {
@@ -34,7 +43,14 @@ public class Tuple {
 	}
 
 	public void setF(byte[] f) {
-		F = f.clone();
+		if (F.length < f.length)
+			throw new LengthNotMatchException(F.length + " < " + f.length);
+		else if (F.length > f.length) {
+			for (int i = 0; i < F.length - f.length; i++)
+				F[i] = 0;
+			System.arraycopy(f, 0, F, F.length - f.length, f.length);
+		} else
+			F = f;
 	}
 
 	public byte[] getN() {
@@ -42,7 +58,14 @@ public class Tuple {
 	}
 
 	public void setN(byte[] n) {
-		N = n.clone();
+		if (N.length < n.length)
+			throw new LengthNotMatchException(N.length + " < " + n.length);
+		else if (N.length > n.length) {
+			for (int i = 0; i < N.length - n.length; i++)
+				N[i] = 0;
+			System.arraycopy(n, 0, N, N.length - n.length, n.length);
+		} else
+			N = n;
 	}
 
 	public byte[] getL() {
@@ -50,7 +73,14 @@ public class Tuple {
 	}
 
 	public void setL(byte[] l) {
-		L = l.clone();
+		if (L.length < l.length)
+			throw new LengthNotMatchException(L.length + " < " + l.length);
+		else if (L.length > l.length) {
+			for (int i = 0; i < L.length - l.length; i++)
+				L[i] = 0;
+			System.arraycopy(l, 0, L, L.length - l.length, l.length);
+		} else
+			L = l;
 	}
 
 	public byte[] getA() {
@@ -58,11 +88,37 @@ public class Tuple {
 	}
 
 	public void setA(byte[] a) {
-		A = a.clone();
+		if (A.length < a.length)
+			throw new LengthNotMatchException(A.length + " < " + a.length);
+		else if (A.length > a.length) {
+			for (int i = 0; i < A.length - a.length; i++)
+				A[i] = 0;
+			System.arraycopy(a, 0, A, A.length - a.length, a.length);
+		} else
+			A = a;
+	}
+
+	public byte[] getALabel(int start, int end) {
+		return Arrays.copyOfRange(A, start, end);
+	}
+
+	public void setALabel(int start, int end, byte[] label) {
+		if (start < 0)
+			throw new IllegalArgumentException(start + " < 0");
+		if (start > end)
+			throw new IllegalArgumentException(start + " > " + end);
+		int len = end - start;
+		if (len < label.length)
+			throw new LengthNotMatchException(len + " < " + label.length);
+		else if (len > label.length) {
+			for (int i = 0; i < len - label.length; i++)
+				A[start + i] = 0;
+		}
+		System.arraycopy(label, 0, A, start + len - label.length, label.length);
 	}
 
 	public byte[] toByteArray() {
-		byte[] tuple = new byte[numBytes];
+		byte[] tuple = new byte[F.length + N.length + L.length + A.length];
 		int offset = 0;
 		System.arraycopy(F, 0, tuple, offset, F.length);
 		offset += F.length;

src/util/Array64.java

@@ -28,7 +28,6 @@ public class Array64<T> {
 		int chunk = (int) (index / CHUNK_SIZE);
 		int offset = (int) (index % CHUNK_SIZE);
 		return data[chunk][offset];
-		// return SerializationUtils.clone(data[chunk][offset]);
 	}
 
 	public void set(long index, T item) {
@@ -37,6 +36,5 @@ public class Array64<T> {
 		int chunk = (int) (index / CHUNK_SIZE);
 		int offset = (int) (index % CHUNK_SIZE);
 		data[chunk][offset] = item;
-		// data[chunk][offset] = SerializationUtils.clone(item);
 	}
 }

test/misc/HelloWorld.java

@@ -14,10 +14,14 @@ public class HelloWorld {
 
 		// System.out.println(tmp[3]);
 
-		System.out.println(Arrays.copyOfRange(tmp, 2, 1).length);
+		//System.out.println(Arrays.copyOfRange(tmp, 2, 1).length);
+		
+		byte[] a = new byte[]{0};
+		byte[] b = a.clone();
+		a[0] = 1;
+		System.out.println(a[0] + " " + b[0]);
 		// throw new ArrayIndexOutOfBoundsException("" + 11);
 
-		long a = 1L << -3;
 	}
 
 }

test/oram/TestMetadata.java

@@ -4,9 +4,10 @@ public class TestMetadata {
 
 	public static void main(String[] args) {
 		Metadata md = new Metadata();
-		md.write("config/copy.yaml");
-		Metadata md2 = new Metadata("config/copy.yaml");
-		md2.write("config/copy2.yaml");
+		md.print();
+		//md.write("config/copy.yaml");
+		//Metadata md2 = new Metadata("config/copy.yaml");
+		//md2.write("config/copy2.yaml");
 	}
 
 }