Merge branch 'byte-buffer-abstraction' into tcp-support

# Conflicts:
#	modules/core/src/main/java/com/illposed/osc/OSCPacketDispatcher.java
#	modules/core/src/main/java/com/illposed/osc/OSCSerializer.java
#	modules/core/src/main/java/com/illposed/osc/OSCSerializerAndParserBuilder.java
#	modules/core/src/main/java/com/illposed/osc/argument/ArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/AwtColorArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/BlobArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/BooleanFalseArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/BooleanTrueArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/ByteArrayBlobArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/CharArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/ColorArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/DateTimeStampArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/DoubleArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/FloatArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/ImpulseArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/IntegerArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/LongArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/MidiMessageArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/NullArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/StringArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/SymbolArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/TimeTag64ArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/argument/handler/UnsignedIntegerArgumentHandler.java
#	modules/core/src/main/java/com/illposed/osc/transport/channel/OSCDatagramChannel.java
#	modules/core/src/test/java/com/illposed/osc/OSCMessageTest.java
#	modules/core/src/test/java/com/illposed/osc/OSCReparserTest.java
#	modules/core/src/test/java/com/illposed/osc/OSCSerializerTest.java
#	modules/core/src/test/java/com/illposed/osc/argument/handler/ColorArgumentHandlerTest.java

Author: hoijui

modules/core/src/main/java/com/illposed/osc/BufferBytesReceiver.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2017, C. Ramakrishnan / Illposed Software.
+ * All rights reserved.
+ *
+ * This code is licensed under the BSD 3-Clause license.
+ * See file LICENSE (or LICENSE.html) for more information.
+ */
+
+package com.illposed.osc;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+
+/**
+ * Implementation of a {@link BytesReceiver} using a {@code ByteBuffer}
+ * as the internal buffer.
+ * This is useful if we know an upper limit for the size
+ * of the expected data in total.
+ * It is thus an ideal candidate for synchronous data receiving,
+ * as is the case in TCP.
+ */
+public class BufferBytesReceiver implements BytesReceiver {
+
+	private final ByteBuffer buffer;
+
+	public BufferBytesReceiver(final ByteBuffer buffer) {
+		this.buffer = buffer;
+	}
+
+	@Override
+	public BytesReceiver put(final byte b) {
+
+		buffer.put(b);
+		return this;
+	}
+
+	@Override
+	public BytesReceiver put(final byte[] src) {
+
+		buffer.put(src);
+		return this;
+	}
+
+	@Override
+	public BytesReceiver put(final ByteBuffer src) {
+
+		buffer.put(src);
+		return this;
+	}
+
+	@Override
+	public BytesReceiver clear() {
+
+		buffer.clear();
+		return this;
+	}
+
+	@Override
+	public int position() {
+		return buffer.position();
+	}
+
+	// HACK try to get rid of this method
+	public ByteBuffer getBuffer() {
+		return buffer;
+	}
+
+	private class PlaceHolderImpl implements PlaceHolder {
+
+		private final int position;
+		private final int size;
+
+		PlaceHolderImpl(final int position, final int size) {
+
+			this.position = position;
+			this.size = size;
+		}
+
+		@Override
+		public void replace(final byte[] src) throws OSCSerializeException {
+
+			if (src.length != size) {
+				throw new OSCSerializeException(String.format(
+						"Trying to replace placeholder of size %d with data of size %d",
+						size, src.length));
+			}
+			final int curPosition = buffer.position();
+			buffer.position(position);
+			put(src);
+			buffer.position(curPosition);
+		}
+	}
+
+	@Override
+	public PlaceHolder putPlaceHolder(final byte[] src) {
+
+		final PlaceHolderImpl placeHolder = new PlaceHolderImpl(position(), src.length);
+		put(src);
+		return placeHolder;
+	}
+
+	@Override
+	public byte[] toByteArray() {
+
+		buffer.flip(); // TODO check if this is always required
+		final byte[] bytes = new byte[buffer.remaining()];
+		buffer.get(bytes);
+		return bytes;
+	}
+}

modules/core/src/main/java/com/illposed/osc/ByteArrayListBytesReceiver.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2017, C. Ramakrishnan / Illposed Software.
+ * All rights reserved.
+ *
+ * This code is licensed under the BSD 3-Clause license.
+ * See file LICENSE (or LICENSE.html) for more information.
+ */
+
+package com.illposed.osc;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Implementation of a {@link BytesReceiver} using a {@code List<byte[]>}
+ * as the internal buffer.
+ * This is useful if we do not now initially know the size
+ * of the expected data in total, and at the same time want to prevent
+ * re-allocating {@code ByteBuffer} or {@code byte[]}
+ * whenever the buffer gets too small.
+ * It is thus an ideal candidate for asynchronous data receiving,
+ * as is the case in UDP.
+ */
+public class ByteArrayListBytesReceiver implements BytesReceiver {
+
+	private final List<byte[]> buffer;
+	private int position;
+
+	public ByteArrayListBytesReceiver() {
+
+		this.buffer = new LinkedList<>();
+		this.position = 0;
+	}
+
+	@Override
+	public BytesReceiver put(final byte b) {
+
+		buffer.add(new byte[] {b});
+		position += 1;
+		return this;
+	}
+
+	@Override
+	public BytesReceiver put(final byte[] src) {
+
+		buffer.add(src);
+		position += src.length;
+		return this;
+	}
+
+	@Override
+	public BytesReceiver put(final ByteBuffer src) {
+		return put(src.array()); // HACK better get rid of this method altogether!
+	}
+
+	@Override
+	public BytesReceiver clear() {
+
+		buffer.clear();
+		return this;
+	}
+
+	@Override
+	public int position() {
+		return position;
+	}
+
+	private class PlaceHolderImpl implements PlaceHolder {
+
+		private final byte[] part;
+
+		PlaceHolderImpl(final byte[] part) {
+
+			this.part = part;
+		}
+
+		@Override
+		public void replace(final byte[] src) throws OSCSerializeException {
+
+			if (src.length != part.length) {
+				throw new OSCSerializeException(String.format(
+						"Trying to replace placeholder of size %d with data of size %d",
+						part.length, src.length));
+			}
+			System.arraycopy(src, 0, part, 0, src.length);
+		}
+	}
+
+	@Override
+	public PlaceHolder putPlaceHolder(final byte[] src) {
+
+		final PlaceHolderImpl placeHolder = new PlaceHolderImpl(src);
+		put(src);
+		return placeHolder;
+	}
+
+	@Override
+	public byte[] toByteArray() {
+
+		final byte[] bytes = new byte[position];
+		int curPos = 0;
+		for (byte[] curPart : buffer) {
+			System.arraycopy(curPart, 0, bytes, curPos, curPart.length);
+			curPos += curPart.length;
+		}
+		return bytes;
+	}
+
+	public void writeTo(final OutputStream out) throws IOException {
+
+		for (final byte[] dataPiece : buffer) {
+			out.write(dataPiece);
+		}
+	}
+}