CBytesWriter
using System;
namespace Common
{
///
/// author : Jave.Lin
/// date : 2018-03-24
///
public class CBytesWriter : IDisposable
{
public static bool IsLittleEndian // return true
{
get { return BitConverter.IsLittleEndian; }
}
private int _m_iPos;
private byte[] _m_pBuffer;
private int _m_iIdx;
private int _m_iLen;
public int iRealPos { get { return _m_iIdx + _m_iPos; } }
public int iPos { get { return _m_iPos; } set { _m_iPos = value; } }
public int iLen { get { return _m_iLen; } }
public int iBuffRemain { get { return Math.Max(_m_iLen - (_m_iIdx + _m_iPos), 0); } }
public CBytesWriter(byte[] buffer, int idx = 0, int len = 0)
{
SetBuffer(buffer, idx, len);
}
public void Dispose()
{
_m_pBuffer = null;
}
public void SetBuffer(byte[] buffer, int idx = 0, int len = 0)
{
_m_pBuffer = buffer;
_m_iIdx = idx;
_m_iLen = len == 0 ? _m_pBuffer.Length : len;
_m_iPos = 0;
_checkBuffLen(_m_iLen);
}
///
/// Attention, it will change original-buffer data!
///
/// reset the offset index of writting
public void TrimtWritten()
{
var remain = iBuffRemain;
var rpos = iRealPos;
if (remain > 0)
{
Buffer.BlockCopy(_m_pBuffer, rpos, _m_pBuffer, _m_iIdx, remain);
}
_m_iPos = 0;
}
public void WriteChar(char value)
{
_checkBuffRemain(2);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 2;
}
public void WriteChar(char[] value)
{
_checkBuffRemain(2);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 2 * value.Length;
}
public void WriteBool(bool value)
{
_checkBuffRemain(1);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 1;
}
public void WriteBool(bool[] value)
{
_checkBuffRemain(1);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += value.Length;
}
public void WriteSByte(sbyte value)
{
_checkBuffRemain(1);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 1;
}
public void WriteByte(byte value)
{
_checkBuffRemain(1);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 1;
}
///
/// Buffer.BlockCopy(writeBuf, writeIdxd, _m_pBuffer, _m_iIdx + _m_iPos, writeLen);
///
public void WriteBytes(byte[] writeBuf, int writeIdxd, int writeLen)
{
if (writeBuf == null)
{
_throwErr(this.GetType().FullName + " WriteBytes argument: writeBuf == null");
}
if (writeLen > (_m_pBuffer.Length - iRealPos))
{
_throwErr(this.GetType().FullName + " WriteBytes argument: writeLen too large");
}
_checkBuffRemain(writeLen);
Buffer.BlockCopy(writeBuf, writeIdxd, _m_pBuffer, _m_iIdx + _m_iPos, writeLen);
_m_iPos += writeLen;
}
public void WriteInt16(short value)
{
_checkBuffRemain(2);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 2;
}
public void WriteUInt16(ushort value)
{
_checkBuffRemain(2);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 2;
}
public void WriteUInt16(ushort[] value)
{
_checkBuffRemain(2);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 2 * value.Length;
}
public void WriteInt32(int value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4;
}
public void WriteInt32(int[] value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4 * value.Length;
}
public void WriteUInt32(uint value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4;
}
public void WriteUInt32(uint[] value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4 * value.Length;
}
public void WriteInt64(long value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8;
}
public void WriteInt64(long[] value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8 * value.Length;
}
public void WriteUInt64(ulong value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8;
}
public void WriteUInt64(ulong[] value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8 * value.Length;
}
public void WriteSingle(float value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4;
}
public void WriteSingle(float[] value)
{
_checkBuffRemain(4);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 4 * value.Length;
}
public void WriteDouble(double value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8;
}
public void WriteDouble(double[] value)
{
_checkBuffRemain(8);
BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
_m_iPos += 8 * value.Length;
}
private void _checkBuffRemain(int value)
{
if (iBuffRemain < value)
{
_throwErr(this.GetType().FullName + " EOB (End of Byte[])");
}
}
private void _checkBuffLen(int value)
{
if (value > iBuffRemain)
{
_throwErr(this.GetType().FullName + " set write buffer's len larger than buffer.Length");
}
}
private void _throwErr(string errMsg)
{
throw new Exception(errMsg);
}
}
} var one = false;
var two = true;
var three = true;
var four = false;
var arrBool = new bool[3] { true, false, true };
var bytes = new byte[200];
var pos = 0;
BitConverterExt.GetBytes(bytes, one, 0);
BitConverterExt.GetBytes(bytes, two, pos += sizeof(bool));
BitConverterExt.GetBytes(bytes, three, pos += sizeof(bool));
BitConverterExt.GetBytes(bytes, four, pos += sizeof(bool));
BitConverterExt.GetBytes(bytes, 'a', pos += sizeof(bool));
BitConverterExt.GetBytes(bytes, arrBool, pos += sizeof(char));
BitConverterExt.GetBytes(bytes, (ushort)0xf0ff, pos += sizeof(bool) * 3);
BitConverterExt.GetBytes(bytes, new char[] { 'A', 'B' }, pos += sizeof(ushort));
BitConverterExt.GetBytes(bytes, new ushort[] { 0xff, 0x8 }, pos += sizeof(char) * 2);
BitConverterExt.GetBytes(bytes, 0xff, pos += sizeof(ushort) * 2);
BitConverterExt.GetBytes(bytes, 0xffffffu, pos += sizeof(int));
BitConverterExt.GetBytes(bytes, 0.999f, pos += sizeof(uint));
BitConverterExt.GetBytes(bytes, 0.999D, pos += sizeof(float));
BitConverterExt.GetBytes(bytes, new int[] { 1, 2, 3, 4 }, pos += sizeof(double));
BitConverterExt.GetBytes(bytes, new uint[] { 5, 6, 7, 8 }, pos += sizeof(int) * 4);
BitConverterExt.GetBytes(bytes, new float[] { 0.1f, 0.2f, 0.3f, 0.4f }, pos += sizeof(uint) * 4);
BitConverterExt.GetBytes(bytes, new double[] { 0.1d, 0.2d, 0.3d, 0.4d }, pos += sizeof(float) * 4);
BitConverterExt.GetBytes(bytes, new long[] { 0xff, 0xffff, 0xffffff, 0xffffffff }, pos += sizeof(double) * 4);
BitConverterExt.GetBytes(bytes, new ulong[] { 0xffff, 0xffffff, 0xffffffff, 0xffffffffff }, pos += sizeof(long) * 4);
var bytes1 = new byte[200];
var writer = new CBytesWriter(bytes1);
writer.WriteBool(one);
writer.WriteBool(two);
writer.WriteBool(three);
writer.WriteBool(four);
writer.WriteChar('a');
writer.WriteBool(arrBool);
writer.WriteUInt16((ushort)0xf0ff);
writer.WriteChar(new char[] { 'A', 'B' });
writer.WriteUInt16(new ushort[] { 0xff, 0x8 });
writer.WriteInt32(0xff);
writer.WriteUInt32(0xffffffu);
writer.WriteSingle(0.999f);
writer.WriteDouble(0.999D);
writer.WriteInt32(new int[] { 1, 2, 3, 4 });
writer.WriteUInt32(new uint[] { 5, 6, 7, 8 });
writer.WriteSingle(new float[] { 0.1f, 0.2f, 0.3f, 0.4f });
writer.WriteDouble(new double[] { 0.1d, 0.2d, 0.3d, 0.4d });
writer.WriteInt64(new long[] { 0xff, 0xffff, 0xffffff, 0xffffffff });
writer.WriteUInt64(new ulong[] { 0xffff, 0xffffff, 0xffffffff, 0xffffffffff });
var equal = Equal(bytes, bytes1);
private static bool Equal(byte[] a, byte[] b)
{
if (a.Length != b.Length) return false;
for (int i = 0, len = a.Length; i < len; ++i)
{
if (a[i] != b[i]) return false;
}
return true;
}+ bytes {byte[200]} byte[]
+ bytes1 {byte[200]} byte[]
equal true bool
+ writer {Common.CBytesWriter} Common.CBytesWriter
