scouter.io.DataOutputX Maven / Gradle / Ivy

/*
 *  Copyright 2015 the original author or authors. 
 *  @https://github.com/scouter-project/scouter
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); 
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License. 
 */

package scouter.io;

import scouter.lang.pack.Pack;
import scouter.lang.step.Step;
import scouter.lang.value.NullValue;
import scouter.lang.value.Value;

import java.io.*;

public class DataOutputX {
	public final static int INT3_MIN_VALUE = 0xff800000;
	public final static int INT3_MAX_VALUE = 0x007fffff;
	public final static long LONG5_MIN_VALUE = 0xffffff8000000000L;
	public final static long LONG5_MAX_VALUE = 0x0000007fffffffffL;

	private int written;
	private DataOutput inner;
	private ByteArrayOutputStream bout;

	public DataOutputX(int size) {
		this(new ByteArrayOutputStream(size));
	}

	public DataOutputX() {
		this(new ByteArrayOutputStream());
	}

	public byte[] toByteArray() {
		if (this.bout != null)
			return bout.toByteArray();
		else
			return null;
	}

	public DataOutputX(ByteArrayOutputStream byteout) {
		this.bout = byteout;
		this.inner = new DataOutputStream(byteout);
	}

	public DataOutputX(BufferedOutputStream anyout) {
		this.inner = new DataOutputStream(anyout);
	}

	public DataOutputX(DataOutputStream out) {
		this.inner = out;
	}

	public DataOutputX(RandomAccessFile out) {
		this.inner = out;
	}

	public DataOutputX writeIntBytes(byte[] b) throws IOException {
		this.writeInt(b.length);
		this.write(b);
		return this;

	}

	public DataOutputX writeShortBytes(byte[] b) throws IOException {
		this.writeShort(b.length);
		this.write(b);
		return this;

	}

	// public DataOutputX flushShortBytes(byte[] b) throws IOException {
	// this.writeShortBytes(b);
	// this.flush();
	// return this;
	// }
	public DataOutputX writeBlob(byte[] value, int offset, int length) throws IOException {
		if (value == null || value.length == 0) {
			writeByte((byte) 0);
		} else {
			int len = Math.min(length, value.length - offset);
			if (len <= 253) {
				writeByte((byte) len);
				write(value, offset, len);
			} else if (len <= 65535) {
				byte[] buff = new byte[3];
				buff[0] = (byte) 255;
				write(toBytes(buff, 1, (short) len));
				write(value, offset, len);
			} else {
				byte[] buff = new byte[5];
				buff[0] = (byte) 254;
				write(toBytes(buff, 1, len));
				write(value, offset, len);
			}
		}
		return this;
	}

	public DataOutputX writeBlob(byte[] value) throws IOException {
		if (value == null || value.length == 0) {
			writeByte((byte) 0);
		} else {
			int len = value.length;
			if (len <= 253) {
				writeByte((byte) len);
				write(value);
			} else if (len <= 65535) {
				byte[] buff = new byte[3];
				buff[0] = (byte) 255; // 255 means value's length is more than 253 bytes.
				write(toBytes(buff, 1, (short) len));
				write(value);
			} else {
				byte[] buff = new byte[5];
				buff[0] = (byte) 254; // 254 means value's length is more than 65535 bytes.
				write(toBytes(buff, 1, len));
				write(value);
			}
		}
		return this;
	}

	public DataOutputX writeText(String s) throws IOException {
		if (s == null) {
			writeByte((byte) 0);
		} else {
			writeBlob(s.getBytes("UTF8"));
		}
		return this;
	}

	public DataOutputX writeText(StringBuffer s) throws IOException {
		if (s == null) {
			writeByte((byte) 0);
		} else {
			writeBlob(s.toString().getBytes("UTF8"));
		}
		return this;
	}

	public DataOutputX writeInt3(int v) throws IOException {
		write(toBytes3(v), 0, 3);
		return this;
	}

	public DataOutputX writeLong5(long v) throws IOException {
		write(toBytes5(v), 0, 5);
		return this;
	}

	public DataOutputX writeDecimal(long v) throws IOException {
		if (v == 0) {
			writeByte(0);
		} else if (Byte.MIN_VALUE <= v && v <= Byte.MAX_VALUE) {
			byte[] b = new byte[2];
			b[0] = 1;
			b[1] = (byte) v;
			write(b);
		} else if (Short.MIN_VALUE <= v && v <= Short.MAX_VALUE) {
			byte[] b = new byte[3];
			b[0] = 2;
			toBytes(b, 1, (short) v);
			write(b);
		} else if (INT3_MIN_VALUE <= v && v <= INT3_MAX_VALUE) {
			byte[] b = new byte[4];
			b[0] = 3;
			write(toBytes3(b, 1, (int) v), 0, 4);
		} else if (Integer.MIN_VALUE <= v && v <= Integer.MAX_VALUE) {
			byte[] b = new byte[5];
			b[0] = 4;
			write(toBytes(b, 1, (int) v), 0, 5);
		} else if (LONG5_MIN_VALUE <= v && v <= LONG5_MAX_VALUE) {
			byte[] b = new byte[6];
			b[0] = 5;
			write(toBytes5(b, 1, v), 0, 6);
		} else if (Long.MIN_VALUE <= v && v <= Long.MAX_VALUE) {
			byte[] b = new byte[9];
			b[0] = 8;
			write(toBytes(b, 1, v), 0, 9);
		}
		return this;
	}

	public DataOutputX wrttenDecimal(long v) throws IOException {
		this.writeDecimal(v);
		this.flush();
		return this;
	}

	public static byte[] toBytes(short v) {
		byte buf[] = new byte[2];
		buf[0] = (byte) ((v >>> 8) & 0xFF);
		buf[1] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes(byte[] buf, int off, short v) {
		buf[off] = (byte) ((v >>> 8) & 0xFF);
		buf[off + 1] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes(int v) {
		byte buf[] = new byte[4];
		buf[0] = (byte) ((v >>> 24) & 0xFF);
		buf[1] = (byte) ((v >>> 16) & 0xFF);
		buf[2] = (byte) ((v >>> 8) & 0xFF);
		buf[3] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes(byte[] buf, int off, int v) {
		buf[off] = (byte) ((v >>> 24) & 0xFF);
		buf[off + 1] = (byte) ((v >>> 16) & 0xFF);
		buf[off + 2] = (byte) ((v >>> 8) & 0xFF);
		buf[off + 3] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes3(int v) {
		byte buf[] = new byte[3];
		buf[0] = (byte) ((v >>> 16) & 0xFF);
		buf[1] = (byte) ((v >>> 8) & 0xFF);
		buf[2] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes3(byte[] buf, int off, int v) {
		buf[off] = (byte) ((v >>> 16) & 0xFF);
		buf[off + 1] = (byte) ((v >>> 8) & 0xFF);
		buf[off + 2] = (byte) ((v >>> 0) & 0xFF);
		return buf;
	}

	public static byte[] toBytes(long v) {
		byte buf[] = new byte[8];
		buf[0] = (byte) (v >>> 56);
		buf[1] = (byte) (v >>> 48);
		buf[2] = (byte) (v >>> 40);
		buf[3] = (byte) (v >>> 32);
		buf[4] = (byte) (v >>> 24);
		buf[5] = (byte) (v >>> 16);
		buf[6] = (byte) (v >>> 8);
		buf[7] = (byte) (v >>> 0);
		return buf;
	}

	public static byte[] toBytes(byte[] buf, int off, long v) {
		buf[off] = (byte) (v >>> 56);
		buf[off + 1] = (byte) (v >>> 48);
		buf[off + 2] = (byte) (v >>> 40);
		buf[off + 3] = (byte) (v >>> 32);
		buf[off + 4] = (byte) (v >>> 24);
		buf[off + 5] = (byte) (v >>> 16);
		buf[off + 6] = (byte) (v >>> 8);
		buf[off + 7] = (byte) (v >>> 0);
		return buf;
	}

	public static byte[] toBytes5(long v) {
		byte writeBuffer[] = new byte[5];
		writeBuffer[0] = (byte) (v >>> 32);
		writeBuffer[1] = (byte) (v >>> 24);
		writeBuffer[2] = (byte) (v >>> 16);
		writeBuffer[3] = (byte) (v >>> 8);
		writeBuffer[4] = (byte) (v >>> 0);
		return writeBuffer;
	}

	public static byte[] toBytes5(byte[] buf, int off, long v) {
		buf[off] = (byte) (v >>> 32);
		buf[off + 1] = (byte) (v >>> 24);
		buf[off + 2] = (byte) (v >>> 16);
		buf[off + 3] = (byte) (v >>> 8);
		buf[off + 4] = (byte) (v >>> 0);
		return buf;
	}

	public static byte[] toBytes(boolean b) {
		if (b)
			return new byte[] { 1 };
		else
			return new byte[] { 0 };
	}

	public static byte[] toBytes(byte[] buf, int off, boolean b) {
		if (b)
			buf[off] = 1;
		else
			buf[off] = 0;
		return buf;
	}

	public static byte[] toBytes(float v) {
		return toBytes(Float.floatToIntBits(v));
	}

	public static byte[] toBytes(byte[] buf, int off, float v) {
		return toBytes(buf, off, Float.floatToIntBits(v));
	}

	public static byte[] toBytes(double v) {
		return toBytes(Double.doubleToLongBits(v));
	}

	public static byte[] toBytes(byte[] buf, int off, double v) {
		return toBytes(buf, off, Double.doubleToLongBits(v));
	}

	public static byte[] set(byte[] dest, int pos, byte[] src) {
		System.arraycopy(src, 0, dest, pos, src.length);
		return dest;
	}

	public DataOutputX writeDecimalArray(int[] v) throws IOException {
		if (v == null) {
			writeDecimal(0);
		} else {
			writeDecimal(v.length);
			for (int i = 0; i < v.length; i++) {
				writeDecimal(v[i]);
			}
		}
		return this;
	}

	public DataOutputX writeDecimalArray(long[] v) throws IOException {
		if (v == null) {
			writeDecimal(0);
		} else {
			writeDecimal(v.length);
			for (int i = 0; i < v.length; i++) {
				writeDecimal(v[i]);
			}
		}
		return this;
	}

	public DataOutputX writeArray(long[] v) throws IOException {
		if (v == null) {
			writeShort(0);
		} else {
			writeShort(v.length);
			for (int i = 0; i < v.length; i++) {
				writeLong(v[i]);
			}
		}
		return this;
	}

	public DataOutputX writeArray(int[] v) throws IOException {
		if (v == null) {
			writeShort(0);
		} else {
			writeShort(v.length);
			for (int i = 0; i < v.length; i++) {
				writeInt(v[i]);
			}
		}
		return this;
	}

	public DataOutputX writeArray(float[] v) throws IOException {
		if (v == null) {
			writeShort(0);
		} else {
			writeShort(v.length);
			for (int i = 0; i < v.length; i++) {
				writeFloat(v[i]);
			}
		}
		return this;
	}

	public DataOutputX writeValue(Value value) throws IOException {
		if (value == null)
			value = NullValue.value;
		this.writeByte(value.getValueType());
		value.write(this);
		return this;
	}

	public DataOutputX writeStep(Step step) throws IOException {
		this.writeByte(step.getStepType());
		step.write(this);
		return this;
	}

	public DataOutputX writePack(Pack packet) throws IOException {
		this.writeByte(packet.getPackType());
		packet.write(this);
		return this;
	}

	public DataOutputX write(byte[] b) throws IOException {
		this.written += b.length;
		this.inner.write(b);
		return this;
	}

	public DataOutputX write(byte[] b, int off, int len) throws IOException {
		this.written += len;
		this.inner.write(b, off, len);
		return this;
	}

	public DataOutputX writeBoolean(boolean v) throws IOException {
		this.written++;
		this.inner.writeBoolean(v);
		return this;
	}

	public DataOutputX writeByte(int v) throws IOException {
		this.written++;
		this.inner.writeByte((byte) v);
		return this;
	}

	public DataOutputX writeShort(int v) throws IOException {
		this.written += 2;
		this.inner.write(toBytes((short) v));
		return this;
	}

	public DataOutputX writeChar(int v) throws IOException {
		this.written += 2;
		this.inner.writeChar(v);
		return this;
	}

	public DataOutputX writeInt(int v) throws IOException {
		this.written += 4;
		this.inner.write(toBytes(v));
		return this;
	}

	public DataOutputX writeLong(long v) throws IOException {
		this.written += 8;
		this.inner.write(toBytes(v));
		return this;
	}

	public DataOutputX writeFloat(float v) throws IOException {
		this.written += 4;
		this.inner.write(toBytes(v));
		return this;
	}

	public DataOutputX writeDouble(double v) throws IOException {
		this.written += 8;
		this.inner.write(toBytes(v));
		return this;
	}

	public int size() {
		return this.written;
	}

	public int getWriteSize() {
		return this.written;
	}

	public void close() throws IOException {
		if (this.inner instanceof RandomAccessFile) {
			((RandomAccessFile) this.inner).close();
		} else if (this.inner instanceof OutputStream) {
			((OutputStream) this.inner).close();
		}
	}

	public void flush() throws IOException {
		if (this.inner instanceof OutputStream) {
			((OutputStream) this.inner).flush();
		}
	}

}