Simplified the serialisation format. Other task #39.

The new format is simpler but less efficient for small integers, short strings and short byte arrays.
2026-02-13 11:19:04 +01:00 · 2014-01-14 22:40:47 +00:00
parent 8886d954d7
commit db96994d5c
15 changed files with 314 additions and 680 deletions
--- a/briar-android/src/org/briarproject/android/contact/SelectContactsDialog.java
+++ b/briar-android/src/org/briarproject/android/contact/SelectContactsDialog.java
@@ -31,6 +31,7 @@ implements DialogInterface.OnMultiChoiceClickListener {

 	@Override
 	public Dialog onCreateDialog(Bundle state) {
+		if(listener == null || contacts == null) return null;
 		AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 		String[] names = new String[contacts.length];
 		for(int i = 0; i < contacts.length; i++)
--- a/briar-api/src/org/briarproject/api/serial/Reader.java
+++ b/briar-api/src/org/briarproject/api/serial/Reader.java
@@ -14,37 +14,13 @@ public interface Reader {
 	boolean readBoolean() throws IOException;
 	void skipBoolean() throws IOException;

-	boolean hasUint7() throws IOException;
-	byte readUint7() throws IOException;
-	void skipUint7() throws IOException;
+	boolean hasInteger() throws IOException;
+	long readInteger() throws IOException;
+	void skipInteger() throws IOException;

-	boolean hasInt8() throws IOException;
-	byte readInt8() throws IOException;
-	void skipInt8() throws IOException;
-
-	boolean hasInt16() throws IOException;
-	short readInt16() throws IOException;
-	void skipInt16() throws IOException;
-
-	boolean hasInt32() throws IOException;
-	int readInt32() throws IOException;
-	void skipInt32() throws IOException;
-
-	boolean hasInt64() throws IOException;
-	long readInt64() throws IOException;
-	void skipInt64() throws IOException;
-
-	boolean hasIntAny() throws IOException;
-	long readIntAny() throws IOException;
-	void skipIntAny() throws IOException;
-
-	boolean hasFloat32() throws IOException;
-	float readFloat32() throws IOException;
-	void skipFloat32() throws IOException;
-
-	boolean hasFloat64() throws IOException;
-	double readFloat64() throws IOException;
-	void skipFloat64() throws IOException;
+	boolean hasFloat() throws IOException;
+	double readFloat() throws IOException;
+	void skipFloat() throws IOException;

 	boolean hasString() throws IOException;
 	String readString(int maxLength) throws IOException;
--- a/briar-api/src/org/briarproject/api/serial/Writer.java
+++ b/briar-api/src/org/briarproject/api/serial/Writer.java
@@ -13,17 +13,8 @@ public interface Writer {
 	void removeConsumer(Consumer c);

 	void writeBoolean(boolean b) throws IOException;
-
-	void writeUint7(byte b) throws IOException;
-	void writeInt8(byte b) throws IOException;
-	void writeInt16(short s) throws IOException;
-	void writeInt32(int i) throws IOException;
-	void writeInt64(long l) throws IOException;
-	void writeIntAny(long l) throws IOException;
-
-	void writeFloat32(float f) throws IOException;
-	void writeFloat64(double d) throws IOException;
-
+	void writeInteger(long l) throws IOException;
+	void writeFloat(double d) throws IOException;
 	void writeString(String s) throws IOException;
 	void writeBytes(byte[] b) throws IOException;

--- a/briar-core/src/org/briarproject/invitation/Connector.java
+++ b/briar-core/src/org/briarproject/invitation/Connector.java
@@ -218,13 +218,13 @@ abstract class Connector extends Thread {
 	}

 	protected void sendTimestamp(Writer w, long timestamp) throws IOException {
-		w.writeInt64(timestamp);
+		w.writeInteger(timestamp);
 		w.flush();
 		if(LOG.isLoggable(INFO)) LOG.info(pluginName + " sent timestamp");
 	}

 	protected long receiveTimestamp(Reader r) throws IOException {
-		long timestamp = r.readInt64();
+		long timestamp = r.readInteger();
 		if(timestamp < 0) throw new FormatException();
 		if(LOG.isLoggable(INFO)) LOG.info(pluginName + " received timestamp");
 		return timestamp;
--- a/briar-core/src/org/briarproject/messaging/MessageFactoryImpl.java
+++ b/briar-core/src/org/briarproject/messaging/MessageFactoryImpl.java
@@ -94,7 +94,7 @@ class MessageFactoryImpl implements MessageFactory {
 		if(author == null) w.writeNull();
 		else writeAuthor(w, author);
 		w.writeString(contentType);
-		w.writeIntAny(timestamp);
+		w.writeInteger(timestamp);
 		byte[] salt = new byte[MESSAGE_SALT_LENGTH];
 		random.nextBytes(salt);
 		w.writeBytes(salt);
--- a/briar-core/src/org/briarproject/messaging/MessageReader.java
+++ b/briar-core/src/org/briarproject/messaging/MessageReader.java
@@ -56,7 +56,7 @@ class MessageReader implements StructReader<UnverifiedMessage> {
 		// Read the content type
 		String contentType = r.readString(MAX_CONTENT_TYPE_LENGTH);
 		// Read the timestamp
-		long timestamp = r.readIntAny();
+		long timestamp = r.readInteger();
 		if(timestamp < 0) throw new FormatException();
 		// Read the salt
 		byte[] salt = r.readBytes(MESSAGE_SALT_LENGTH);
--- a/briar-core/src/org/briarproject/messaging/PacketReaderImpl.java
+++ b/briar-core/src/org/briarproject/messaging/PacketReaderImpl.java
@@ -165,7 +165,7 @@ class PacketReaderImpl implements PacketReader {

 	public RetentionAck readRetentionAck() throws IOException {
 		r.readStructStart(RETENTION_ACK);
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		r.readStructEnd();
 		return new RetentionAck(version);
@@ -177,9 +177,9 @@ class PacketReaderImpl implements PacketReader {

 	public RetentionUpdate readRetentionUpdate() throws IOException {
 		r.readStructStart(RETENTION_UPDATE);
-		long retention = r.readIntAny();
+		long retention = r.readInteger();
 		if(retention < 0) throw new FormatException();
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		r.readStructEnd();
 		return new RetentionUpdate(retention, version);
@@ -191,7 +191,7 @@ class PacketReaderImpl implements PacketReader {

 	public SubscriptionAck readSubscriptionAck() throws IOException {
 		r.readStructStart(SUBSCRIPTION_ACK);
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		r.readStructEnd();
 		return new SubscriptionAck(version);
@@ -213,7 +213,7 @@ class PacketReaderImpl implements PacketReader {
 		r.readStructStart(TRANSPORT_ACK);
 		byte[] b = r.readBytes(UniqueId.LENGTH);
 		if(b.length < UniqueId.LENGTH) throw new FormatException();
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		r.readStructEnd();
 		return new TransportAck(new TransportId(b), version);
@@ -245,7 +245,7 @@ class PacketReaderImpl implements PacketReader {
 		}
 		r.readMapEnd();
 		// Read the version number
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		// Read the end of the struct
 		r.readStructEnd();
--- a/briar-core/src/org/briarproject/messaging/PacketWriterImpl.java
+++ b/briar-core/src/org/briarproject/messaging/PacketWriterImpl.java
@@ -101,22 +101,22 @@ class PacketWriterImpl implements PacketWriter {

 	public void writeRetentionAck(RetentionAck a) throws IOException {
 		w.writeStructStart(RETENTION_ACK);
-		w.writeIntAny(a.getVersion());
+		w.writeInteger(a.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}

 	public void writeRetentionUpdate(RetentionUpdate u) throws IOException {
 		w.writeStructStart(RETENTION_UPDATE);
-		w.writeIntAny(u.getRetentionTime());
-		w.writeIntAny(u.getVersion());
+		w.writeInteger(u.getRetentionTime());
+		w.writeInteger(u.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}

 	public void writeSubscriptionAck(SubscriptionAck a) throws IOException {
 		w.writeStructStart(SUBSCRIPTION_ACK);
-		w.writeIntAny(a.getVersion());
+		w.writeInteger(a.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}
@@ -132,7 +132,7 @@ class PacketWriterImpl implements PacketWriter {
 			w.writeStructEnd();
 		}
 		w.writeListEnd();
-		w.writeIntAny(u.getVersion());
+		w.writeInteger(u.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}
@@ -140,7 +140,7 @@ class PacketWriterImpl implements PacketWriter {
 	public void writeTransportAck(TransportAck a) throws IOException {
 		w.writeStructStart(TRANSPORT_ACK);
 		w.writeBytes(a.getId().getBytes());
-		w.writeIntAny(a.getVersion());
+		w.writeInteger(a.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}
@@ -149,7 +149,7 @@ class PacketWriterImpl implements PacketWriter {
 		w.writeStructStart(TRANSPORT_UPDATE);
 		w.writeBytes(u.getId().getBytes());
 		w.writeMap(u.getProperties());
-		w.writeIntAny(u.getVersion());
+		w.writeInteger(u.getVersion());
 		w.writeStructEnd();
 		if(flush) out.flush();
 	}
--- a/briar-core/src/org/briarproject/messaging/SubscriptionUpdateReader.java
+++ b/briar-core/src/org/briarproject/messaging/SubscriptionUpdateReader.java
@@ -38,7 +38,7 @@ class SubscriptionUpdateReader implements StructReader<SubscriptionUpdate> {
 			groups.add(groupReader.readStruct(r));
 		r.readListEnd();
 		// Read the version number
-		long version = r.readIntAny();
+		long version = r.readInteger();
 		if(version < 0) throw new FormatException();
 		// Read the end of the struct
 		r.readStructEnd();
--- a/briar-core/src/org/briarproject/serial/ReaderImpl.java
+++ b/briar-core/src/org/briarproject/serial/ReaderImpl.java
@@ -1,5 +1,17 @@
 package org.briarproject.serial;

+import static org.briarproject.serial.Tag.BYTES;
+import static org.briarproject.serial.Tag.END;
+import static org.briarproject.serial.Tag.FALSE;
+import static org.briarproject.serial.Tag.FLOAT;
+import static org.briarproject.serial.Tag.INTEGER;
+import static org.briarproject.serial.Tag.LIST;
+import static org.briarproject.serial.Tag.MAP;
+import static org.briarproject.serial.Tag.NULL;
+import static org.briarproject.serial.Tag.STRING;
+import static org.briarproject.serial.Tag.STRUCT;
+import static org.briarproject.serial.Tag.TRUE;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -25,15 +37,9 @@ class ReaderImpl implements Reader {
 		this.in = in;
 	}

-	public boolean eof() throws IOException {
-		if(!hasLookahead) readLookahead();
-		return eof;
-	}
-
 	private void readLookahead() throws IOException {
 		assert !eof;
-		// If one or two lookahead bytes have been read, feed the consumers
-		if(hasLookahead) consumeLookahead();
+		assert !hasLookahead;
 		// Read a lookahead byte
 		int i = in.read();
 		if(i == -1) {
@@ -42,7 +48,7 @@ class ReaderImpl implements Reader {
 		}
 		next = (byte) i;
 		// If necessary, read another lookahead byte
-		if(next == Tag.STRUCT) {
+		if(next == STRUCT) {
 			i = in.read();
 			if(i == -1) throw new FormatException();
 			nextStructId = (byte) i;
@@ -54,11 +60,68 @@ class ReaderImpl implements Reader {
 		assert hasLookahead;
 		for(Consumer c : consumers) {
 			c.write(next);
-			if(next == Tag.STRUCT) c.write(nextStructId);
+			if(next == STRUCT) c.write(nextStructId);
 		}
 		hasLookahead = false;
 	}

+	private void readIntoBuffer(byte[] b, int length, boolean consume)
+			throws IOException {
+		int offset = 0;
+		while(offset < length) {
+			int read = in.read(b, offset, length - offset);
+			if(read == -1) throw new FormatException();
+			offset += read;
+		}
+		if(consume) for(Consumer c : consumers) c.write(b, 0, length);
+	}
+
+	private void readIntoBuffer(int length, boolean consume)
+			throws IOException {
+		if(buf.length < length) buf = new byte[length];
+		readIntoBuffer(buf, length, consume);
+	}
+
+	private int readInt32(boolean consume) throws IOException {
+		readIntoBuffer(4, consume);
+		int value = 0;
+		for(int i = 0; i < 4; i++) value |= (buf[i] & 0xFF) << (24 - i * 8);
+		return value;
+	}
+
+	private long readInt64(boolean consume) throws IOException {
+		readIntoBuffer(8, consume);
+		long value = 0;
+		for(int i = 0; i < 8; i++) value |= (buf[i] & 0xFFL) << (56 - i * 8);
+		return value;
+	}
+
+	private void skip(int length) throws IOException {
+		while(length > 0) {
+			int read = in.read(buf, 0, Math.min(length, buf.length));
+			if(read == -1) throw new FormatException();
+			length -= read;
+		}
+	}
+
+	private void skipObject() throws IOException {
+		if(hasBoolean()) skipBoolean();
+		else if(hasInteger()) skipInteger();
+		else if(hasFloat()) skipFloat();
+		else if(hasString()) skipString(Integer.MAX_VALUE);
+		else if(hasBytes()) skipBytes(Integer.MAX_VALUE);
+		else if(hasList()) skipList();
+		else if(hasMap()) skipMap();
+		else if(hasStruct()) skipStruct();
+		else if(hasNull()) skipNull();
+		else throw new FormatException();
+	}
+
+	public boolean eof() throws IOException {
+		if(!hasLookahead) readLookahead();
+		return eof;
+	}
+
 	public void close() throws IOException {
 		in.close();
 	}
@@ -74,13 +137,13 @@ class ReaderImpl implements Reader {
 	public boolean hasBoolean() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.FALSE || next == Tag.TRUE;
+		return next == FALSE || next == TRUE;
 	}

 	public boolean readBoolean() throws IOException {
 		if(!hasBoolean()) throw new FormatException();
 		consumeLookahead();
-		return next == Tag.TRUE;
+		return next == TRUE;
 	}

 	public void skipBoolean() throws IOException {
@@ -88,289 +151,95 @@ class ReaderImpl implements Reader {
 		hasLookahead = false;
 	}

-	public boolean hasUint7() throws IOException {
+	public boolean hasInteger() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next >= 0;
+		return next == INTEGER;
 	}

-	public byte readUint7() throws IOException {
-		if(!hasUint7()) throw new FormatException();
+	public long readInteger() throws IOException {
+		if(!hasInteger()) throw new FormatException();
 		consumeLookahead();
-		return next;
+		return readInt64(true);
 	}

-	public void skipUint7() throws IOException {
-		if(!hasUint7()) throw new FormatException();
-		hasLookahead = false;
-	}
-
-	public boolean hasInt8() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next == Tag.INT8;
-	}
-
-	public byte readInt8() throws IOException {
-		if(!hasInt8()) throw new FormatException();
-		consumeLookahead();
-		int i = in.read();
-		if(i == -1) {
-			eof = true;
-			throw new FormatException();
-		}
-		byte b = (byte) i;
-		// Feed the hungry mouths
-		for(Consumer c : consumers) c.write(b);
-		return b;
-	}
-
-	public void skipInt8() throws IOException {
-		if(!hasInt8()) throw new FormatException();
-		if(in.read() == -1) {
-			eof = true;
-			throw new FormatException();
-		}
-		hasLookahead = false;
-	}
-
-	public boolean hasInt16() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next == Tag.INT16;
-	}
-
-	public short readInt16() throws IOException {
-		if(!hasInt16()) throw new FormatException();
-		consumeLookahead();
-		readIntoBuffer(2);
-		return (short) (((buf[0] & 0xFF) << 8) | (buf[1] & 0xFF));
-	}
-
-	private void readIntoBuffer(int length) throws IOException {
-		if(buf.length < length) buf = new byte[length];
-		readIntoBuffer(buf, length);
-	}
-
-	private void readIntoBuffer(byte[] b, int length) throws IOException {
-		assert !hasLookahead;
-		int offset = 0;
-		while(offset < length) {
-			int read = in.read(b, offset, length - offset);
-			if(read == -1) {
-				eof = true;
-				throw new FormatException();
-			}
-			offset += read;
-		}
-		// Feed the hungry mouths
-		for(Consumer c : consumers) c.write(b, 0, length);
-	}
-
-	public void skipInt16() throws IOException {
-		if(!hasInt16()) throw new FormatException();
-		hasLookahead = false;
-		skip(2);
-	}
-
-	private void skip(int length) throws IOException {
-		while(length > 0) {
-			int read = in.read(buf, 0, Math.min(length, buf.length));
-			if(read == -1) {
-				eof = true;
-				throw new FormatException();
-			}
-			length -= read;
-		}
-	}
-
-	public boolean hasInt32() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next == Tag.INT32;
-	}
-
-	public int readInt32() throws IOException {
-		if(!hasInt32()) throw new FormatException();
-		consumeLookahead();
-		return readInt32Bits();
-	}
-
-	private int readInt32Bits() throws IOException {
-		readIntoBuffer(4);
-		return ((buf[0] & 0xFF) << 24) | ((buf[1] & 0xFF) << 16) |
-				((buf[2] & 0xFF) << 8) | (buf[3] & 0xFF);
-	}
-
-	public void skipInt32() throws IOException {
-		if(!hasInt32()) throw new FormatException();
-		hasLookahead = false;
-		skip(4);
-	}
-
-	public boolean hasInt64() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next == Tag.INT64;
-	}
-
-	public long readInt64() throws IOException {
-		if(!hasInt64()) throw new FormatException();
-		consumeLookahead();
-		return readInt64Bits();
-	}
-
-	private long readInt64Bits() throws IOException {
-		readIntoBuffer(8);
-		return ((buf[0] & 0xFFL) << 56) | ((buf[1] & 0xFFL) << 48) |
-				((buf[2] & 0xFFL) << 40) | ((buf[3] & 0xFFL) << 32) |
-				((buf[4] & 0xFFL) << 24) | ((buf[5] & 0xFFL) << 16) |
-				((buf[6] & 0xFFL) << 8) | (buf[7] & 0xFFL);
-	}
-
-	public void skipInt64() throws IOException {
-		if(!hasInt64()) throw new FormatException();
-		hasLookahead = false;
+	public void skipInteger() throws IOException {
+		if(!hasInteger()) throw new FormatException();
 		skip(8);
-	}
-
-	public boolean hasIntAny() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next >= 0 || next == Tag.INT8 || next == Tag.INT16
-				|| next == Tag.INT32 || next == Tag.INT64;
-	}
-
-	public long readIntAny() throws IOException {
-		if(!hasIntAny()) throw new FormatException();
-		if(next >= 0) return readUint7();
-		if(next == Tag.INT8) return readInt8();
-		if(next == Tag.INT16) return readInt16();
-		if(next == Tag.INT32) return readInt32();
-		if(next == Tag.INT64) return readInt64();
-		throw new IllegalStateException();
-	}
-
-	public void skipIntAny() throws IOException {
-		if(!hasIntAny()) throw new FormatException();
-		if(next >= 0) skipUint7();
-		else if(next == Tag.INT8) skipInt8();
-		else if(next == Tag.INT16) skipInt16();
-		else if(next == Tag.INT32) skipInt32();
-		else if(next == Tag.INT64) skipInt64();
-		else throw new IllegalStateException();
-	}
-
-	public boolean hasFloat32() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next == Tag.FLOAT32;
-	}
-
-	public float readFloat32() throws IOException {
-		if(!hasFloat32()) throw new FormatException();
-		consumeLookahead();
-		return Float.intBitsToFloat(readInt32Bits());
-	}
-
-	public void skipFloat32() throws IOException {
-		if(!hasFloat32()) throw new FormatException();
 		hasLookahead = false;
-		skip(4);
 	}

-	public boolean hasFloat64() throws IOException {
+	public boolean hasFloat() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.FLOAT64;
+		return next == FLOAT;
 	}

-	public double readFloat64() throws IOException {
-		if(!hasFloat64()) throw new FormatException();
+	public double readFloat() throws IOException {
+		if(!hasFloat()) throw new FormatException();
 		consumeLookahead();
-		return Double.longBitsToDouble(readInt64Bits());
+		return Double.longBitsToDouble(readInt64(true));
 	}

-	public void skipFloat64() throws IOException {
-		if(!hasFloat64()) throw new FormatException();
-		hasLookahead = false;
+	public void skipFloat() throws IOException {
+		if(!hasFloat()) throw new FormatException();
 		skip(8);
+		hasLookahead = false;
 	}

 	public boolean hasString() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.STRING;
+		return next == STRING;
 	}

 	public String readString(int maxLength) throws IOException {
 		if(!hasString()) throw new FormatException();
 		consumeLookahead();
-		int length = readLength();
-		if(length > maxLength) throw new FormatException();
+		int length = readInt32(true);
+		if(length < 0 || length > maxLength) throw new FormatException();
 		if(length == 0) return "";
-		readIntoBuffer(length);
+		readIntoBuffer(length, true);
 		return new String(buf, 0, length, "UTF-8");
 	}

-	private int readLength() throws IOException {
-		if(!hasLength()) throw new FormatException();
-		int length;
-		if(next >= 0) length = readUint7();
-		else if(next == Tag.INT8) length = readInt8();
-		else if(next == Tag.INT16) length = readInt16();
-		else if(next == Tag.INT32) length = readInt32();
-		else throw new IllegalStateException();
-		if(length < 0) throw new FormatException();
-		return length;
-	}
-
-	private boolean hasLength() throws IOException {
-		if(!hasLookahead) readLookahead();
-		if(eof) return false;
-		return next >= 0 || next == Tag.INT8 || next == Tag.INT16
-				|| next == Tag.INT32;
-	}
-
 	public void skipString(int maxLength) throws IOException {
 		if(!hasString()) throw new FormatException();
-		hasLookahead = false;
-		int length = readLength();
-		if(length > maxLength) throw new FormatException();
-		hasLookahead = false;
+		int length = readInt32(false);
+		if(length < 0 || length > maxLength) throw new FormatException();
 		skip(length);
+		hasLookahead = false;
 	}

 	public boolean hasBytes() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.BYTES;
+		return next == BYTES;
 	}

 	public byte[] readBytes(int maxLength) throws IOException {
 		if(!hasBytes()) throw new FormatException();
 		consumeLookahead();
-		int length = readLength();
-		if(length > maxLength) throw new FormatException();
+		int length = readInt32(true);
+		if(length < 0 || length > maxLength) throw new FormatException();
 		if(length == 0) return EMPTY_BUFFER;
 		byte[] b = new byte[length];
-		readIntoBuffer(b, length);
+		readIntoBuffer(b, length, true);
 		return b;
 	}

 	public void skipBytes(int maxLength) throws IOException {
 		if(!hasBytes()) throw new FormatException();
-		hasLookahead = false;
-		int length = readLength();
-		if(length > maxLength) throw new FormatException();
-		hasLookahead = false;
+		int length = readInt32(false);
+		if(length < 0 || length > maxLength) throw new FormatException();
 		skip(length);
+		hasLookahead = false;
 	}

 	public boolean hasList() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.LIST;
+		return next == LIST;
 	}

 	public void readListStart() throws IOException {
@@ -385,7 +254,7 @@ class ReaderImpl implements Reader {
 	private boolean hasEnd() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.END;
+		return next == END;
 	}

 	public void readListEnd() throws IOException {
@@ -404,24 +273,10 @@ class ReaderImpl implements Reader {
 		hasLookahead = false;
 	}

-	private void skipObject() throws IOException {
-		if(hasBoolean()) skipBoolean();
-		else if(hasIntAny()) skipIntAny();
-		else if(hasFloat32()) skipFloat32();
-		else if(hasFloat64()) skipFloat64();
-		else if(hasString()) skipString(Integer.MAX_VALUE);
-		else if(hasBytes()) skipBytes(Integer.MAX_VALUE);
-		else if(hasList()) skipList();
-		else if(hasMap()) skipMap();
-		else if(hasStruct()) skipStruct();
-		else if(hasNull()) skipNull();
-		else throw new FormatException();
-	}
-
 	public boolean hasMap() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.MAP;
+		return next == MAP;
 	}

 	public void readMapStart() throws IOException {
@@ -450,14 +305,14 @@ class ReaderImpl implements Reader {
 	public boolean hasStruct() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.STRUCT;
+		return next == STRUCT;
 	}

 	public boolean hasStruct(int id) throws IOException {
 		if(id < 0 || id > 255) throw new IllegalArgumentException();
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.STRUCT && (nextStructId & 0xFF) == id;
+		return next == STRUCT && (nextStructId & 0xFF) == id;
 	}

 	public void readStructStart(int id) throws IOException {
@@ -483,7 +338,7 @@ class ReaderImpl implements Reader {
 	public boolean hasNull() throws IOException {
 		if(!hasLookahead) readLookahead();
 		if(eof) return false;
-		return next == Tag.NULL;
+		return next == NULL;
 	}

 	public void readNull() throws IOException {
--- a/briar-core/src/org/briarproject/serial/SerialComponentImpl.java
+++ b/briar-core/src/org/briarproject/serial/SerialComponentImpl.java
@@ -16,7 +16,7 @@ class SerialComponentImpl implements SerialComponent {
 	}

 	public int getSerialisedStructStartLength(int id) {
-		// STRUCT tag, ID
+		// STRUCT tag, 8-bit ID
 		return 2;
 	}

@@ -26,14 +26,7 @@ class SerialComponentImpl implements SerialComponent {
 	}

 	public int getSerialisedUniqueIdLength() {
-		// BYTES tag, length spec, bytes
-		return 1 + getSerialisedLengthSpecLength(UniqueId.LENGTH)
-				+ UniqueId.LENGTH;
-	}
-
-	private int getSerialisedLengthSpecLength(int length) {
-		if(length < 0) throw new IllegalArgumentException();
-		// Uint7, int16 or int32
-		return length <= Byte.MAX_VALUE ? 1 : length <= Short.MAX_VALUE ? 3 : 5;
+		// BYTES tag, 32-bit length, bytes
+		return 5 + UniqueId.LENGTH;
 	}
 }
--- a/briar-core/src/org/briarproject/serial/Tag.java
+++ b/briar-core/src/org/briarproject/serial/Tag.java
@@ -2,19 +2,15 @@ package org.briarproject.serial;

 interface Tag {

-	byte FALSE = (byte) 0xFF;
-	byte TRUE = (byte) 0xFE;
-	byte INT8 = (byte) 0xFD;
-	byte INT16 = (byte) 0xFC;
-	byte INT32 = (byte) 0xFB;
-	byte INT64 = (byte) 0xFA;
-	byte FLOAT32 = (byte) 0xF9;
-	byte FLOAT64 = (byte) 0xF8;
-	byte STRING = (byte) 0xF7;
-	byte BYTES = (byte) 0xF6;
-	byte LIST = (byte) 0xF5;
-	byte MAP = (byte) 0xF4;
-	byte STRUCT = (byte) 0xF3;
-	byte END = (byte) 0xF2;
-	byte NULL = (byte) 0xF1;
+	byte FALSE = 0;
+	byte TRUE = 1;
+	byte INTEGER = 2;
+	byte FLOAT = 3;
+	byte STRING = 4;
+	byte BYTES = 5;
+	byte LIST = 6;
+	byte MAP = 7;
+	byte STRUCT = 8;
+	byte END = 9;
+	byte NULL = 10;
 }
--- a/briar-core/src/org/briarproject/serial/WriterImpl.java
+++ b/briar-core/src/org/briarproject/serial/WriterImpl.java
@@ -1,5 +1,11 @@
 package org.briarproject.serial;

+import static org.briarproject.serial.Tag.FALSE;
+import static org.briarproject.serial.Tag.FLOAT;
+import static org.briarproject.serial.Tag.INTEGER;
+import static org.briarproject.serial.Tag.STRING;
+import static org.briarproject.serial.Tag.TRUE;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
@@ -39,44 +45,16 @@ class WriterImpl implements Writer {
 	}

 	public void writeBoolean(boolean b) throws IOException {
-		if(b) write(Tag.TRUE);
-		else write(Tag.FALSE);
+		if(b) write(TRUE);
+		else write(FALSE);
 	}

-	public void writeUint7(byte b) throws IOException {
-		if(b < 0) throw new IllegalArgumentException();
-		write(b);
+	public void writeInteger(long l) throws IOException {
+		write(INTEGER);
+		writeInt64(l);
 	}

-	public void writeInt8(byte b) throws IOException {
-		write(Tag.INT8);
-		write(b);
-	}
-
-	public void writeInt16(short s) throws IOException {
-		write(Tag.INT16);
-		write((byte) (s >> 8));
-		write((byte) ((s << 8) >> 8));
-	}
-
-	public void writeInt32(int i) throws IOException {
-		write(Tag.INT32);
-		writeInt32Bits(i);
-	}
-
-	private void writeInt32Bits(int i) throws IOException {
-		write((byte) (i >> 24));
-		write((byte) ((i << 8) >> 24));
-		write((byte) ((i << 16) >> 24));
-		write((byte) ((i << 24) >> 24));
-	}
-
-	public void writeInt64(long l) throws IOException {
-		write(Tag.INT64);
-		writeInt64Bits(l);
-	}
-
-	private void writeInt64Bits(long l) throws IOException {
+	private void writeInt64(long l) throws IOException {
 		write((byte) (l >> 56));
 		write((byte) ((l << 8) >> 56));
 		write((byte) ((l << 16) >> 56));
@@ -87,41 +65,24 @@ class WriterImpl implements Writer {
 		write((byte) ((l << 56) >> 56));
 	}

-	public void writeIntAny(long l) throws IOException {
-		if(l >= 0 && l <= Byte.MAX_VALUE)
-			writeUint7((byte) l);
-		else if(l >= Byte.MIN_VALUE && l <= Byte.MAX_VALUE)
-			writeInt8((byte) l);
-		else if(l >= Short.MIN_VALUE && l <= Short.MAX_VALUE)
-			writeInt16((short) l);
-		else if(l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE)
-			writeInt32((int) l);
-		else writeInt64(l);
-	}
-
-	public void writeFloat32(float f) throws IOException {
-		write(Tag.FLOAT32);
-		writeInt32Bits(Float.floatToRawIntBits(f));
-	}
-
-	public void writeFloat64(double d) throws IOException {
-		write(Tag.FLOAT64);
-		writeInt64Bits(Double.doubleToRawLongBits(d));
+	public void writeFloat(double d) throws IOException {
+		write(FLOAT);
+		writeInt64(Double.doubleToRawLongBits(d));
 	}

 	public void writeString(String s) throws IOException {
 		byte[] b = s.getBytes("UTF-8");
-		write(Tag.STRING);
+		write(STRING);
 		writeLength(b.length);
 		write(b);
 	}

 	private void writeLength(int i) throws IOException {
 		assert i >= 0;
-		// Fun fact: it's never worth writing a length as an int8
-		if(i <= Byte.MAX_VALUE) writeUint7((byte) i);
-		else if(i <= Short.MAX_VALUE) writeInt16((short) i);
-		else writeInt32(i);
+		write((byte) (i >> 24));
+		write((byte) ((i << 8) >> 24));
+		write((byte) ((i << 16) >> 24));
+		write((byte) ((i << 24) >> 24));
 	}

 	public void writeBytes(byte[] b) throws IOException {
@@ -138,13 +99,14 @@ class WriterImpl implements Writer {

 	private void writeObject(Object o) throws IOException {
 		if(o instanceof Boolean) writeBoolean((Boolean) o);
-		else if(o instanceof Byte) writeIntAny((Byte) o);
-		else if(o instanceof Short) writeIntAny((Short) o);
-		else if(o instanceof Integer) writeIntAny((Integer) o);
-		else if(o instanceof Long) writeIntAny((Long) o);
-		else if(o instanceof Float) writeFloat32((Float) o);
-		else if(o instanceof Double) writeFloat64((Double) o);
+		else if(o instanceof Byte) writeInteger((Byte) o);
+		else if(o instanceof Short) writeInteger((Short) o);
+		else if(o instanceof Integer) writeInteger((Integer) o);
+		else if(o instanceof Long) writeInteger((Long) o);
+		else if(o instanceof Float) writeFloat((Float) o);
+		else if(o instanceof Double) writeFloat((Double) o);
 		else if(o instanceof String) writeString((String) o);
+		else if(o instanceof byte[]) writeBytes((byte[]) o);
 		else if(o instanceof Bytes) writeBytes(((Bytes) o).getBytes());
 		else if(o instanceof List<?>) writeList((List<?>) o);
 		else if(o instanceof Map<?, ?>) writeMap((Map<?, ?>) o);
--- a/briar-tests/src/org/briarproject/serial/ReaderImplTest.java
+++ b/briar-tests/src/org/briarproject/serial/ReaderImplTest.java
@@ -7,7 +7,6 @@ import java.io.ByteArrayInputStream;
 import org.briarproject.BriarTestCase;
 import org.briarproject.api.FormatException;
 import org.briarproject.util.StringUtils;
-
 import org.junit.Test;

 public class ReaderImplTest extends BriarTestCase {
@@ -17,7 +16,7 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testReadBoolean() throws Exception {
-		setContents("FF" + "FE");
+		setContents("00" + "01");
 		assertFalse(r.readBoolean());
 		assertTrue(r.readBoolean());
 		assertTrue(r.eof());
@@ -25,160 +24,60 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipBoolean() throws Exception {
-		setContents("FF" + "FE");
+		setContents("00" + "01");
 		r.skipBoolean();
 		r.skipBoolean();
 		assertTrue(r.eof());
 	}

 	@Test
-	public void testReadInt8() throws Exception {
-		setContents("FD00" + "FDFF" + "FD7F" + "FD80");
-		assertEquals((byte) 0, r.readInt8());
-		assertEquals((byte) -1, r.readInt8());
-		assertEquals(Byte.MAX_VALUE, r.readInt8());
-		assertEquals(Byte.MIN_VALUE, r.readInt8());
+	public void testReadInteger() throws Exception {
+		setContents("02" + "0000000000000000" + "02" + "FFFFFFFFFFFFFFFF"
+				+ "02" + "7FFFFFFFFFFFFFFF" + "02" + "8000000000000000");
+		assertEquals(0, r.readInteger());
+		assertEquals(-1, r.readInteger());
+		assertEquals(Long.MAX_VALUE, r.readInteger());
+		assertEquals(Long.MIN_VALUE, r.readInteger());
 		assertTrue(r.eof());
 	}

 	@Test
-	public void testSkipInt8() throws Exception {
-		setContents("FD00");
-		r.skipInt8();
+	public void testSkipInteger() throws Exception {
+		setContents("02" + "0000000000000000");
+		r.skipInteger();
 		assertTrue(r.eof());
 	}

 	@Test
-	public void testReadInt16() throws Exception {
-		setContents("FC0000" + "FCFFFF" + "FC7FFF" + "FC8000");
-		assertEquals((short) 0, r.readInt16());
-		assertEquals((short) -1, r.readInt16());
-		assertEquals(Short.MAX_VALUE, r.readInt16());
-		assertEquals(Short.MIN_VALUE, r.readInt16());
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testSkipInt16() throws Exception {
-		setContents("FC0000");
-		r.skipInt16();
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testReadInt32() throws Exception {
-		setContents("FB00000000" + "FBFFFFFFFF" + "FB7FFFFFFF" + "FB80000000");
-		assertEquals(0, r.readInt32());
-		assertEquals(-1, r.readInt32());
-		assertEquals(Integer.MAX_VALUE, r.readInt32());
-		assertEquals(Integer.MIN_VALUE, r.readInt32());
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testSkipInt32() throws Exception {
-		setContents("FB00000000");
-		r.skipInt32();
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testReadInt64() throws Exception {
-		setContents("FA0000000000000000" + "FAFFFFFFFFFFFFFFFF"
-				+ "FA7FFFFFFFFFFFFFFF" + "FA8000000000000000");
-		assertEquals(0, r.readInt64());
-		assertEquals(-1, r.readInt64());
-		assertEquals(Long.MAX_VALUE, r.readInt64());
-		assertEquals(Long.MIN_VALUE, r.readInt64());
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testSkipInt64() throws Exception {
-		setContents("FA0000000000000000");
-		r.skipInt64();
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testReadIntAny() throws Exception {
-		setContents("00" + "7F" + "FD80" + "FDFF" + "FC0080" + "FC7FFF"
-				+ "FB00008000" + "FB7FFFFFFF" + "FA0000000080000000");
-		assertEquals(0, r.readIntAny());
-		assertEquals(127, r.readIntAny());
-		assertEquals(-128, r.readIntAny());
-		assertEquals(-1, r.readIntAny());
-		assertEquals(128, r.readIntAny());
-		assertEquals(32767, r.readIntAny());
-		assertEquals(32768, r.readIntAny());
-		assertEquals(2147483647, r.readIntAny());
-		assertEquals(2147483648L, r.readIntAny());
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testSkipIntAny() throws Exception {
-		setContents("00" + "FD00" + "FC0000" + "FB00000000"
-				+ "FA0000000000000000");
-		r.skipIntAny();
-		r.skipIntAny();
-		r.skipIntAny();
-		r.skipIntAny();
-		r.skipIntAny();
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testReadFloat32() throws Exception {
+	public void testReadFloat() throws Exception {
 		// http://babbage.cs.qc.edu/IEEE-754/Decimal.html
 		// http://steve.hollasch.net/cgindex/coding/ieeefloat.html
-		setContents("F900000000" + "F93F800000" + "F940000000" + "F9BF800000"
-				+ "F980000000" + "F9FF800000" + "F97F800000" + "F97FC00000");
-		assertEquals(0F, r.readFloat32());
-		assertEquals(1F, r.readFloat32());
-		assertEquals(2F, r.readFloat32());
-		assertEquals(-1F, r.readFloat32());
-		assertEquals(-0F, r.readFloat32());
-		assertEquals(Float.NEGATIVE_INFINITY, r.readFloat32());
-		assertEquals(Float.POSITIVE_INFINITY, r.readFloat32());
-		assertTrue(Float.isNaN(r.readFloat32()));
+		setContents("03" + "0000000000000000" + "03" + "3FF0000000000000"
+				+ "03" + "4000000000000000" + "03" + "BFF0000000000000"
+				+ "03" + "8000000000000000" + "03" + "FFF0000000000000"
+				+ "03" + "7FF0000000000000" + "03" + "7FF8000000000000");
+		assertEquals(0.0, r.readFloat());
+		assertEquals(1.0, r.readFloat());
+		assertEquals(2.0, r.readFloat());
+		assertEquals(-1.0, r.readFloat());
+		assertEquals(-0.0, r.readFloat());
+		assertEquals(Double.NEGATIVE_INFINITY, r.readFloat());
+		assertEquals(Double.POSITIVE_INFINITY, r.readFloat());
+		assertTrue(Double.isNaN(r.readFloat()));
 		assertTrue(r.eof());
 	}

 	@Test
-	public void testSkipFloat32() throws Exception {
-		setContents("F900000000");
-		r.skipFloat32();
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testReadFloat64() throws Exception {
-		setContents("F80000000000000000" + "F83FF0000000000000"
-				+ "F84000000000000000" + "F8BFF0000000000000"
-				+ "F88000000000000000" + "F8FFF0000000000000"
-				+ "F87FF0000000000000" + "F87FF8000000000000");
-		assertEquals(0.0, r.readFloat64());
-		assertEquals(1.0, r.readFloat64());
-		assertEquals(2.0, r.readFloat64());
-		assertEquals(-1.0, r.readFloat64());
-		assertEquals(-0.0, r.readFloat64());
-		assertEquals(Double.NEGATIVE_INFINITY, r.readFloat64());
-		assertEquals(Double.POSITIVE_INFINITY, r.readFloat64());
-		assertTrue(Double.isNaN(r.readFloat64()));
-		assertTrue(r.eof());
-	}
-
-	@Test
-	public void testSkipFloat64() throws Exception {
-		setContents("F80000000000000000");
-		r.skipFloat64();
+	public void testSkipFloat() throws Exception {
+		setContents("03" + "0000000000000000");
+		r.skipFloat();
 		assertTrue(r.eof());
 	}

 	@Test
 	public void testReadString() throws Exception {
-		setContents("F703666F6F" + "F700");
+		// "foo" and the empty string
+		setContents("04" + "00000003" + "666F6F" + "04" + "00000000");
 		assertEquals("foo", r.readString(Integer.MAX_VALUE));
 		assertEquals("", r.readString(Integer.MAX_VALUE));
 		assertTrue(r.eof());
@@ -186,8 +85,11 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testReadStringMaxLength() throws Exception {
-		setContents("F703666F6F" + "F703666F6F");
+		// "foo" twice
+		setContents("04" + "00000003" + "666F6F" +
+				"04" + "00000003" + "666F6F");
 		assertEquals("foo", r.readString(3));
+		assertTrue(r.hasString());
 		try {
 			r.readString(2);
 			fail();
@@ -196,7 +98,8 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipString() throws Exception {
-		setContents("F703666F6F" + "F700");
+		// "foo" and the empty string
+		setContents("04" + "00000003" + "666F6F" + "04" + "00000000");
 		r.skipString(Integer.MAX_VALUE);
 		r.skipString(Integer.MAX_VALUE);
 		assertTrue(r.eof());
@@ -204,8 +107,11 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipStringMaxLength() throws Exception {
-		setContents("F703666F6F" + "F703666F6F");
+		// "foo" twice
+		setContents("04" + "00000003" + "666F6F" +
+				"04" + "00000003" + "666F6F");
 		r.skipString(3);
+		assertTrue(r.hasString());
 		try {
 			r.skipString(2);
 			fail();
@@ -214,7 +120,8 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testReadBytes() throws Exception {
-		setContents("F603010203" + "F600");
+		// {1, 2, 3} and {}
+		setContents("05" + "00000003" + "010203" + "05" + "00000000");
 		assertArrayEquals(new byte[] {1, 2, 3}, r.readBytes(Integer.MAX_VALUE));
 		assertArrayEquals(new byte[] {}, r.readBytes(Integer.MAX_VALUE));
 		assertTrue(r.eof());
@@ -222,8 +129,11 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testReadBytesMaxLength() throws Exception {
-		setContents("F603010203" + "F603010203");
+		// {1, 2, 3} twice
+		setContents("05" + "00000003" + "010203" +
+				"05" + "00000003" + "010203");
 		assertArrayEquals(new byte[] {1, 2, 3}, r.readBytes(3));
+		assertTrue(r.hasBytes());
 		try {
 			r.readBytes(2);
 			fail();
@@ -232,7 +142,8 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipBytes() throws Exception {
-		setContents("F603010203" + "F600");
+		// {1, 2, 3} and {}
+		setContents("05" + "00000003" + "010203" + "05" + "00000000");
 		r.skipBytes(Integer.MAX_VALUE);
 		r.skipBytes(Integer.MAX_VALUE);
 		assertTrue(r.eof());
@@ -240,8 +151,11 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipBytesMaxLength() throws Exception {
-		setContents("F603010203" + "F603010203");
+		// {1, 2, 3} twice
+		setContents("05" + "00000003" + "010203" +
+				"05" + "00000003" + "010203");
 		r.skipBytes(3);
+		assertTrue(r.hasBytes());
 		try {
 			r.skipBytes(2);
 			fail();
@@ -250,14 +164,17 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testReadList() throws Exception {
-		setContents("F5" + "01" + "F703666F6F" + "FC0080" + "F2");
+		// A list containing 2, "foo", and 128
+		setContents("06" + "02" + "0000000000000001" +
+				"04" + "00000003" + "666F6F" +
+				"02" + "0000000000000080" + "09");
 		r.readListStart();
 		assertFalse(r.hasListEnd());
-		assertEquals((byte) 1, r.readIntAny());
+		assertEquals(1, r.readInteger());
 		assertFalse(r.hasListEnd());
 		assertEquals("foo", r.readString(1000));
 		assertFalse(r.hasListEnd());
-		assertEquals((short) 128, r.readIntAny());
+		assertEquals(128, r.readInteger());
 		assertTrue(r.hasListEnd());
 		r.readListEnd();
 		assertTrue(r.eof());
@@ -265,19 +182,24 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipList() throws Exception {
-		setContents("F5" + "01" + "F703666F6F" + "FC0080" + "F2");
+		// A list containing 2, "foo", and 128
+		setContents("06" + "02" + "0000000000000001" +
+				"04" + "00000003" + "666F6F" +
+				"02" + "0000000000000080" + "09");
 		r.skipList();
 		assertTrue(r.eof());
 	}

 	@Test
 	public void testReadMap() throws Exception {
-		setContents("F4" + "F703666F6F" + "7B" + "F600" + "F1" + "F2");
+		// A map containing "foo" -> 123 and {} -> null
+		setContents("07" + "04" + "00000003" + "666F6F" +
+				"02" + "000000000000007B" + "05" + "00000000" + "0A" + "09");
 		r.readMapStart();
 		assertFalse(r.hasMapEnd());
 		assertEquals("foo", r.readString(1000));
 		assertFalse(r.hasMapEnd());
-		assertEquals((byte) 123, r.readIntAny());
+		assertEquals(123, r.readInteger());
 		assertFalse(r.hasMapEnd());
 		assertArrayEquals(new byte[] {}, r.readBytes(1000));
 		assertFalse(r.hasMapEnd());
@@ -290,7 +212,9 @@ public class ReaderImplTest extends BriarTestCase {

 	@Test
 	public void testSkipMap() throws Exception {
-		setContents("F4" + "F703666F6F" + "7B" + "F600" + "F1" + "F2");
+		// A map containing "foo" -> 123 and {} -> null
+		setContents("07" + "04" + "00000003" + "666F6F" +
+				"02" + "000000000000007B" + "05" + "00000000" + "0A" + "09");
 		r.skipMap();
 		assertTrue(r.eof());
 	}
@@ -298,7 +222,7 @@ public class ReaderImplTest extends BriarTestCase {
 	@Test
 	public void testReadStruct() throws Exception {
 		// Two empty structs with IDs 0 and 255
-		setContents("F300" + "F2" + "F3FF" + "F2");
+		setContents("0800" + "09" + "08FF" + "09");
 		r.readStructStart(0);
 		r.readStructEnd();
 		r.readStructStart(255);
@@ -309,7 +233,7 @@ public class ReaderImplTest extends BriarTestCase {
 	@Test
 	public void testSkipStruct() throws Exception {
 		// Two empty structs with IDs 0 and 255
-		setContents("F300" + "F2" + "F3FF" + "F2");
+		setContents("0800" + "09" + "08FF" + "09");
 		r.skipStruct();
 		r.skipStruct();
 		assertTrue(r.eof());
@@ -318,21 +242,21 @@ public class ReaderImplTest extends BriarTestCase {
 	@Test
 	public void testSkipNestedStructMapAndList() throws Exception {
 		// A struct containing a map containing two empty lists
-		setContents("F300" + "F4" + "F5" + "F2" + "F5" + "F2" + "F2" + "F2");
+		setContents("0800" + "07" + "06" + "09" + "06" + "09" + "09" + "09");
 		r.skipStruct();
 		assertTrue(r.eof());
 	}

 	@Test
 	public void testReadNull() throws Exception {
-		setContents("F1");
+		setContents("0A");
 		r.readNull();
 		assertTrue(r.eof());
 	}

 	@Test
 	public void testSkipNull() throws Exception {
-		setContents("F1");
+		setContents("0A");
 		r.skipNull();
 		assertTrue(r.eof());
 	}
--- a/briar-tests/src/org/briarproject/serial/WriterImplTest.java
+++ b/briar-tests/src/org/briarproject/serial/WriterImplTest.java
@@ -10,7 +10,6 @@ import java.util.Map;

 import org.briarproject.BriarTestCase;
 import org.briarproject.util.StringUtils;
-
 import org.junit.Before;
 import org.junit.Test;

@@ -30,114 +29,43 @@ public class WriterImplTest extends BriarTestCase {
 		w.writeBoolean(true);
 		w.writeBoolean(false);
 		// TRUE tag, FALSE tag
-		checkContents("FE" + "FF");
+		checkContents("01" + "00");
 	}

 	@Test
-	public void testWriteUint7() throws IOException {
-		w.writeUint7((byte) 0);
-		w.writeUint7(Byte.MAX_VALUE);
-		// 0, 127
-		checkContents("00" + "7F");
+	public void testWriteInteger() throws IOException {
+		w.writeInteger(0);
+		w.writeInteger(-1);
+		w.writeInteger(Long.MIN_VALUE);
+		w.writeInteger(Long.MAX_VALUE);
+		// INTEGER tag, 0, INTEGER tag, -1, etc
+		checkContents("02" + "0000000000000000" + "02" + "FFFFFFFFFFFFFFFF"
+				+ "02" + "8000000000000000" + "02" + "7FFFFFFFFFFFFFFF");
 	}

 	@Test
-	public void testWriteInt8() throws IOException {
-		w.writeInt8((byte) 0);
-		w.writeInt8((byte) -1);
-		w.writeInt8(Byte.MIN_VALUE);
-		w.writeInt8(Byte.MAX_VALUE);
-		// INT8 tag, 0, INT8 tag, -1, INT8 tag, -128, INT8 tag, 127
-		checkContents("FD" + "00" + "FD" + "FF" + "FD" + "80" + "FD" + "7F");
-	}
-
-	@Test
-	public void testWriteInt16() throws IOException {
-		w.writeInt16((short) 0);
-		w.writeInt16((short) -1);
-		w.writeInt16(Short.MIN_VALUE);
-		w.writeInt16(Short.MAX_VALUE);
-		// INT16 tag, 0, INT16 tag, -1, INT16 tag, -32768, INT16 tag, 32767
-		checkContents("FC" + "0000" + "FC" + "FFFF" + "FC" + "8000"
-				+ "FC" + "7FFF");
-	}
-
-	@Test
-	public void testWriteInt32() throws IOException {
-		w.writeInt32(0);
-		w.writeInt32(-1);
-		w.writeInt32(Integer.MIN_VALUE);
-		w.writeInt32(Integer.MAX_VALUE);
-		// INT32 tag, 0, INT32 tag, -1, etc
-		checkContents("FB" + "00000000" + "FB" + "FFFFFFFF" + "FB" + "80000000"
-				+ "FB" + "7FFFFFFF");
-	}
-
-	@Test
-	public void testWriteInt64() throws IOException {
-		w.writeInt64(0);
-		w.writeInt64(-1);
-		w.writeInt64(Long.MIN_VALUE);
-		w.writeInt64(Long.MAX_VALUE);
-		// INT64 tag, 0, INT64 tag, -1, etc
-		checkContents("FA" + "0000000000000000" + "FA" + "FFFFFFFFFFFFFFFF"
-				+ "FA" + "8000000000000000" + "FA" + "7FFFFFFFFFFFFFFF");
-	}
-
-	@Test
-	public void testWriteIntAny() throws IOException {
-		w.writeIntAny(0); // uint7
-		w.writeIntAny(-1); // int8
-		w.writeIntAny(Byte.MAX_VALUE); // uint7
-		w.writeIntAny(Byte.MAX_VALUE + 1); // int16
-		w.writeIntAny(Short.MAX_VALUE); // int16
-		w.writeIntAny(Short.MAX_VALUE + 1); // int32
-		w.writeIntAny(Integer.MAX_VALUE); // int32
-		w.writeIntAny(Integer.MAX_VALUE + 1L); // int64
-		checkContents("00" + "FDFF" + "7F" + "FC0080" + "FC7FFF"
-				+ "FB00008000" + "FB7FFFFFFF" + "FA0000000080000000");
-	}
-
-	@Test
-	public void testWriteFloat32() throws IOException {
+	public void testWriteFloat() throws IOException {
 		// http://babbage.cs.qc.edu/IEEE-754/Decimal.html
-		// 1 bit for sign, 8 for exponent, 23 for significand
-		w.writeFloat32(0F); // 0 0 0 -> 0x00000000
-		w.writeFloat32(1F); // 0 127 1 -> 0x3F800000
-		w.writeFloat32(2F); // 0 128 1 -> 0x40000000
-		w.writeFloat32(-1F); // 1 127 1 -> 0xBF800000
-		w.writeFloat32(-0F); // 1 0 0 -> 0x80000000
-		// http://steve.hollasch.net/cgindex/coding/ieeefloat.html
-		w.writeFloat32(Float.NEGATIVE_INFINITY); // 1 255 0 -> 0xFF800000
-		w.writeFloat32(Float.POSITIVE_INFINITY); // 0 255 0 -> 0x7F800000
-		w.writeFloat32(Float.NaN); // 0 255 1 -> 0x7FC00000
-		checkContents("F9" + "00000000" + "F9" + "3F800000" + "F9" + "40000000"
-				+ "F9" + "BF800000" + "F9" + "80000000" + "F9" + "FF800000"
-				+ "F9" + "7F800000" + "F9" + "7FC00000");
-	}
-
-	@Test
-	public void testWriteFloat64() throws IOException {
 		// 1 bit for sign, 11 for exponent, 52 for significand
-		w.writeFloat64(0.0); // 0 0 0 -> 0x0000000000000000
-		w.writeFloat64(1.0); // 0 1023 1 -> 0x3FF0000000000000
-		w.writeFloat64(2.0); // 0 1024 1 -> 0x4000000000000000
-		w.writeFloat64(-1.0); // 1 1023 1 -> 0xBFF0000000000000
-		w.writeFloat64(-0.0); // 1 0 0 -> 0x8000000000000000
-		w.writeFloat64(Double.NEGATIVE_INFINITY); // 1 2047 0 -> 0xFFF00000...
-		w.writeFloat64(Double.POSITIVE_INFINITY); // 0 2047 0 -> 0x7FF00000...
-		w.writeFloat64(Double.NaN); // 0 2047 1 -> 0x7FF8000000000000
-		checkContents("F8" + "0000000000000000" + "F8" + "3FF0000000000000"
-				+ "F8" + "4000000000000000" + "F8" + "BFF0000000000000"
-				+ "F8" + "8000000000000000" + "F8" + "FFF0000000000000"
-				+ "F8" + "7FF0000000000000" + "F8" + "7FF8000000000000");
+		w.writeFloat(0.0); // 0 0 0 -> 0x0000000000000000
+		w.writeFloat(1.0); // 0 1023 1 -> 0x3FF0000000000000
+		w.writeFloat(2.0); // 0 1024 1 -> 0x4000000000000000
+		w.writeFloat(-1.0); // 1 1023 1 -> 0xBFF0000000000000
+		w.writeFloat(-0.0); // 1 0 0 -> 0x8000000000000000
+		w.writeFloat(Double.NEGATIVE_INFINITY); // 1 2047 0 -> 0xFFF00000...
+		w.writeFloat(Double.POSITIVE_INFINITY); // 0 2047 0 -> 0x7FF00000...
+		w.writeFloat(Double.NaN); // 0 2047 1 -> 0x7FF8000000000000
+		checkContents("03" + "0000000000000000" + "03" + "3FF0000000000000"
+				+ "03" + "4000000000000000" + "03" + "BFF0000000000000"
+				+ "03" + "8000000000000000" + "03" + "FFF0000000000000"
+				+ "03" + "7FF0000000000000" + "03" + "7FF8000000000000");
 	}

 	@Test
 	public void testWriteString() throws IOException {
 		w.writeString("foo bar baz bam ");
-		// STRING tag, length 16 as uint7, UTF-8 bytes
-		checkContents("F7" + "10" + "666F6F206261722062617A2062616D20");
+		// STRING tag, length 16, UTF-8 bytes
+		checkContents("04" + "00000010" + "666F6F206261722062617A2062616D20");
 	}

 	@Test
@@ -145,17 +73,18 @@ public class WriterImplTest extends BriarTestCase {
 		w.writeBytes(new byte[] {
 				0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 		});
-		// BYTES tag, length 16 as uint7, bytes
-		checkContents("F6" + "10" + "000102030405060708090A0B0C0D0E0F");
+		// BYTES tag, length 16, bytes
+		checkContents("05" + "00000010" + "000102030405060708090A0B0C0D0E0F");
 	}

 	@Test
 	public void testWriteList() throws IOException {
 		List<Object> l = new ArrayList<Object>();
-		for(int i = 0; i < 16; i++) l.add(i);
+		for(int i = 0; i < 3; i++) l.add(i);
 		w.writeList(l);
-		// LIST tag, elements as uint7, END tag
-		checkContents("F5" + "000102030405060708090A0B0C0D0E0F" + "F2");
+		// LIST tag, elements as integers, END tag
+		checkContents("06" + "02" + "0000000000000000" +
+				"02" + "0000000000000001" + "02" + "0000000000000002" + "09");
 	}

 	@Test
@@ -165,59 +94,66 @@ public class WriterImplTest extends BriarTestCase {
 		l.add(null);
 		l.add(2);
 		w.writeList(l);
-		// LIST tag, 1 as uint7, null, 2 as uint7, END tag
-		checkContents("F5" + "01" + "F1" + "02" + "F2");
+		// LIST tag, 1 as integer, NULL tag, 2 as integer, END tag
+		checkContents("06" + "02" + "0000000000000001" + "0A" +
+				"02" + "0000000000000002" + "09");
 	}

 	@Test
 	public void testWriteMap() throws IOException {
 		// Use LinkedHashMap to get predictable iteration order
 		Map<Object, Object> m = new LinkedHashMap<Object, Object>();
-		for(int i = 0; i < 16; i++) m.put(i, i + 1);
+		for(int i = 0; i < 4; i++) m.put(i, i + 1);
 		w.writeMap(m);
-		// MAP tag, entries as uint7, END tag
-		checkContents("F4" + "0001" + "0102" + "0203" + "0304" + "0405"
-				+ "0506" + "0607" + "0708" + "0809" + "090A" + "0A0B" + "0B0C"
-				+ "0C0D" + "0D0E" + "0E0F" + "0F10" + "F2");
+		// MAP tag, entries as integers, END tag
+		checkContents("07" + "02" + "0000000000000000" +
+				"02" + "0000000000000001" + "02" + "0000000000000001" +
+				"02" + "0000000000000002" + "02" + "0000000000000002" +
+				"02" + "0000000000000003" + "02" + "0000000000000003" +
+				"02" + "0000000000000004" + "09");
 	}

 	@Test
 	public void testWriteDelimitedList() throws IOException {
 		w.writeListStart();
-		w.writeIntAny((byte) 1); // Written as uint7
-		w.writeString("foo"); // Written as string
-		w.writeIntAny(128L); // Written as int16
+		w.writeInteger(1);
+		w.writeString("foo");
+		w.writeInteger(128);
 		w.writeListEnd();
-		// LIST tag, 1 as uint7, "foo" as string, 128 as int16, END tag
-		checkContents("F5" + "01" + "F703666F6F" + "FC0080" + "F2");
+		// LIST tag, 1 as integer, "foo" as string, 128 as integer, END tag
+		checkContents("06" + "02" + "0000000000000001" +
+				"04" + "00000003" + "666F6F" +
+				"02" + "0000000000000080" + "09");
 	}

 	@Test
 	public void testWriteDelimitedMap() throws IOException {
 		w.writeMapStart();
-		w.writeString("foo"); // Written as string
-		w.writeIntAny(123); // Written as uint7
-		w.writeBytes(new byte[0]); // Written as bytes
+		w.writeString("foo");
+		w.writeInteger(123);
+		w.writeBytes(new byte[0]);
 		w.writeNull();
 		w.writeMapEnd();
-		// MAP tag, "foo" as string, 123 as uint7, byte[0] as bytes,
-		// NULL tag, END tag
-		checkContents("F4" + "F703666F6F" + "7B" + "F600" + "F1" + "F2");
+		// MAP tag, "foo" as string, 123 as integer, {} as bytes, NULL tag,
+		// END tag
+		checkContents("07" + "04" + "00000003" + "666F6F" +
+				"02" + "000000000000007B" + "05" + "00000000" + "0A" + "09");
 	}

 	@Test
 	public void testWriteNestedMapsAndLists() throws IOException {
 		Map<Object, Object> m = new LinkedHashMap<Object, Object>();
-		m.put("foo", Integer.valueOf(123));
+		m.put("foo", 123);
 		List<Object> l = new ArrayList<Object>();
-		l.add(Byte.valueOf((byte) 1));
+		l.add((byte) 1);
 		Map<Object, Object> m1 = new LinkedHashMap<Object, Object>();
 		m1.put(m, l);
 		w.writeMap(m1);
-		// MAP tag, MAP tag, "foo" as string, 123 as uint7, END tag,
-		// LIST tag, 1 as uint7, END tag, END tag
-		checkContents("F4" + "F4" + "F703666F6F" + "7B" + "F2"
-				+ "F5" + "01" + "F2" + "F2");
+		// MAP tag, MAP tag, "foo" as string, 123 as integer, END tag,
+		// LIST tag, 1 as integer, END tag, END tag
+		checkContents("07" + "07" + "04" + "00000003" + "666F6F" +
+				"02" + "000000000000007B" + "09" + "06" +
+				"02" + "0000000000000001" + "09" + "09");
 	}

 	@Test
@@ -225,13 +161,13 @@ public class WriterImplTest extends BriarTestCase {
 		w.writeStructStart(123);
 		w.writeStructEnd();
 		// STRUCT tag, 123 as struct ID, END tag
-		checkContents("F3" + "7B" + "F2");
+		checkContents("08" + "7B" + "09");
 	}

 	@Test
 	public void testWriteNull() throws IOException {
 		w.writeNull();
-		checkContents("F1");
+		checkContents("0A");
 	}

 	private void checkContents(String hex) throws IOException {