Binary.java

package FlexibleEncoding.Parquet;

/*
 * adapted  from Parquet*
 */


import java.io.DataOutput;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.Arrays;

abstract public class Binary {

	public static final Binary EMPTY = fromByteArray(new byte[0]);

	public static Binary fromByteArray(
			final byte[] value,
			final int offset,
			final int length) {

		return new Binary() {
			@Override
			public  Binary  copyBianry(byte bytes){
				value[0]=bytes ;
				return this ;
			}

			@Override
			public String toStringUsingUTF8() {
				return  BytesUtils.UTF8.decode(ByteBuffer.wrap(value, offset, length)).toString();
				// TODO: figure out why the following line was much slower
				// return new String(value, offset, length, BytesUtils.UTF8);
			}

			@Override
			public int length() {
				return length;
			}

			@Override
			public void writeTo(OutputStream out) throws IOException {
				out.write(value, offset, length);
			}

			@Override
			public byte[] getBytes() {
				return Arrays.copyOfRange(value, offset, offset + length);
			}

			@Override
			public int hashCode() {
				return Binary.hashCode(value, offset, length);
			}

			@Override
			boolean equals(Binary other) {
				return other.equals(value, offset, length);
			}

			@Override
			boolean equals(byte[] other, int otherOffset, int otherLength) {
				return Binary.equals(value, offset, length, other, otherOffset, otherLength);
			}

			@Override
			public ByteBuffer toByteBuffer() {
				return ByteBuffer.wrap(value, offset, length);
			}

			@Override
			public void writeTo(DataOutput out) throws IOException {
				out.write(value, offset, length);
			}

		};
	}

	public static Binary fromByteArray(final byte[] value) {
		return new Binary() {
			@Override
			public String toStringUsingUTF8() {
				return new String(value, BytesUtils.UTF8);
			}

			@Override
			public int length() {
				return value.length;
			}

			@Override
			public void writeTo(OutputStream out) throws IOException {
				out.write(value);
			}

			@Override
			public byte[] getBytes() {
				return value;
			}

			@Override
			public int hashCode() {
				return Binary.hashCode(value, 0, value.length);
			}

			@Override
			boolean equals(Binary other) {
				return other.equals(value, 0, value.length);
			}

			@Override
			boolean equals(byte[] other, int otherOffset, int otherLength) {
				return Binary.equals(value, 0, value.length, other, otherOffset, otherLength);
			}

			@Override
			public ByteBuffer toByteBuffer() {
				return ByteBuffer.wrap(value);
			}

			@Override
			public void writeTo(DataOutput out) throws IOException {
				out.write(value);
			}

			@Override
			public Binary  copyBianry(byte bytes) {
				// TODO Auto-generated method stub
			value[0]=bytes ;
				return  this ;
			}
		};
	}

	public static Binary fromByteBuffer(final ByteBuffer value) {
		return new Binary() {
			@Override
			public String toStringUsingUTF8() {
				return new String(getBytes(), BytesUtils.UTF8);
			}

			@Override
			public int length() {
				return value.remaining();
			}

			@Override
			public void writeTo(OutputStream out) throws IOException {
				// TODO: should not have to materialize those bytes
				out.write(getBytes());
			}

			@Override
			public byte[] getBytes() {
				byte[] bytes = new byte[value.remaining()];

				value.mark();
				value.get(bytes).reset();
				return bytes;
			}

			@Override
			public int hashCode() {
				if (value.hasArray()) {
					return Binary.hashCode(value.array(), value.arrayOffset() + value.position(),
							value.arrayOffset() + value.remaining());
				}
				byte[] bytes = getBytes();
				return Binary.hashCode(bytes, 0, bytes.length);
			}

			@Override
			boolean equals(Binary other) {
				if (value.hasArray()) {
					return other.equals(value.array(), value.arrayOffset() + value.position(),
							value.arrayOffset() + value.remaining());
				}
				byte[] bytes = getBytes();
				return other.equals(bytes, 0, bytes.length);
			}

			@Override
			boolean equals(byte[] other, int otherOffset, int otherLength) {
				if (value.hasArray()) {
					return Binary.equals(value.array(), value.arrayOffset() + value.position(),
							value.arrayOffset() + value.remaining(), other, otherOffset, otherLength);
				}
				byte[] bytes = getBytes();
				return Binary.equals(bytes, 0, bytes.length, other, otherOffset, otherLength);
			}

			@Override
			public ByteBuffer toByteBuffer() {
				return value;
			}

			@Override
			public void writeTo(DataOutput out) throws IOException {
				// TODO: should not have to materialize those bytes
				out.write(getBytes());
			}

			@Override
			public Binary copyBianry(byte bytes) {
				// TODO Auto-generated method stub
				//value[0]=bytes ;
				return null ;
			}
		};
	}

	public static Binary fromString(final String value) {
		try {
			return fromByteArray(value.getBytes("UTF-8"));
		} catch (UnsupportedEncodingException e) {
			throw new ParquetEncodingException("UTF-8 not supported.", e);
		}
	}

	/**
	 * @see {@link Arrays#hashCode(byte[])}
	 * @param array
	 * @param offset
	 * @param length
	 * @return
	 */
	private static final int hashCode(byte[] array, int offset, int length) {
		int result = 1;
		for (int i = offset; i < offset + length; i++) {
			byte b = array[i];
			result = 31 * result + b;
		}
		return result;
	}

	/**
	 * @see {@link Arrays#equals(byte[], byte[])}
	 * @param array1
	 * @param offset1
	 * @param length1
	 * @param array2
	 * @param offset2
	 * @param length2
	 * @return
	 */
	private static final boolean equals(byte[] array1, int offset1, int length1, byte[] array2, int offset2, int length2) {
		if (array1 == null && array2 == null) return true;
		if (array1 == null || array2 == null) return false;
		if (length1 != length2) return false;
		if (array1 == array2 && offset1 == offset2) return true;
		for (int i = 0; i < length1; i++) {
			if (array1[i + offset1] != array2[i + offset2]) {
				return false;
			}
		}
		return true;
	}
	//  final byte[] value,
	//  final int offset,
	//  final int length)
	// public void copyBianry(byte bytes){
	//	 value
	// }
	abstract public String toStringUsingUTF8();

	abstract public int length();

	abstract public void writeTo(OutputStream out) throws IOException;

	abstract public void writeTo(DataOutput out) throws IOException;

	abstract public byte[] getBytes();

	abstract boolean equals(byte[] bytes, int offset, int length);

	abstract boolean equals(Binary other);
	abstract public Binary   copyBianry(byte bytes);
	

	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		if (obj instanceof Binary) {
			return equals((Binary)obj);
		}
		return false;
	}

	abstract public ByteBuffer toByteBuffer();

	public String toString() {
		return "Binary{" + length() + " bytes, " + toStringUsingUTF8() + "}";
	};
}