csharp-code-ClassStream

abstract class ClassStream
{
    private static int s_mStreamLength;
    private static byte[] s_byteBuffer = new byte[20];
    private static byte[] s_helpsBuffer = new byte[20];

    private static UTF8Encoding s_encoding = new UTF8Encoding();
    private static MemoryStream s_mStream = new MemoryStream(10240);

    private const int SHORT_SIZE = sizeof(short);
    private const int USHORT_SIZE = sizeof(ushort);
    private const int INT_SIZE = sizeof(int);
    private const int UINT_SIZE = sizeof(uint);
    private const int LONG_SIZE = sizeof(long);
    private const int ULONG_SIZE = sizeof(ulong);
    private const int FLOAT_SIZE = sizeof(float);
    private const int DOUBLE_SIZE = sizeof(double);

    public abstract void Write();
    public abstract void Read();

    public static void StartWrite()
    {
        s_mStream.Position = 0;
        s_mStreamLength = 0;
    }

    public static void StartRead(byte[] bytes)
    {
        s_mStream.Position = 0;
        s_mStream.Write(bytes, 0, bytes.Length);
        s_mStream.Position = 0;
        s_mStreamLength = bytes.Length;
    }

    public static byte[] ToArray()
    {
        return s_mStream.ToArray();
    }

    private void WriteBigEndian(byte[] bytes)
    {
        if(bytes == null)
        {
            throw new IOException("null byte[] write to stream!");
        }

        s_mStreamLength += bytes.Length;
        for (int i = bytes.Length - 1; i >= 0; i--)
        {
            s_mStream.WriteByte(bytes[i]);
        }
    }

    private void ReadByteToBuffer(int numBytes)
    {
        if (s_mStreamLength - s_mStream.Position < numBytes)
        {
            throw new IOException("Stream Is End");
        }

        int num;
        for (int i = 0; i < numBytes; i += num)
        {
            num = s_mStream.Read(s_byteBuffer, i, numBytes - i);
        }
    }

    private void ReadByteToBuffer(int numBytes, byte[] buff)
    {
        if (s_mStreamLength - s_mStream.Position < numBytes)
        {
            throw new IOException("Stream Is End");
        }

        s_mStream.Read(buff, 0, numBytes);
    }

    protected void WriteByte(byte value)
    {
        s_mStream.WriteByte(value);
    }

    protected void WriteBytes(byte[] values)
    {
        if (values == null)
        {
            throw new IOException("null byte[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for(int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteByte(values[dataIdx]);
        }
    }

    protected void WriteBool(bool value)
    {
        s_mStream.WriteByte(value ? (byte)1 : (byte)0);
    }

    protected void WriteBools(bool[] values)
    {
        if (values == null)
        {
            throw new IOException("null bool[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteBool(values[dataIdx]);
        }
    }

    protected void WriteShort(short value)
    {
        s_helpsBuffer[1] = (byte)value;
        s_helpsBuffer[0] = (byte)(value >> 8);

        s_mStream.Write(s_helpsBuffer, 0, SHORT_SIZE);
    }

    protected void WriteShorts(short[] values)
    {
        if (values == null)
        {
            throw new IOException("null short[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteShort(values[dataIdx]);
        }
    }

    protected void WriteUshort(ushort value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteUshorts(ushort[] values)
    {
        if (values == null)
        {
            throw new IOException("null ushort[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteUshort(values[dataIdx]);
        }
    }

    protected void WriteInt(int value)
    {
        s_helpsBuffer[3] = (byte)value;
        s_helpsBuffer[2] = (byte)(value >> 8);
        s_helpsBuffer[1] = (byte)(value >> 16);
        s_helpsBuffer[0] = (byte)(value >> 24);

        s_mStream.Write(s_helpsBuffer, 0, INT_SIZE);
    }

    protected void WriteInts(int[] values)
    {
        if (values == null)
        {
            throw new IOException("null int[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteInt(values[dataIdx]);
        }
    }

    protected void WriteUint(uint value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteUints(uint[] values)
    {
        if (values == null)
        {
            throw new IOException("null uint[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteUint(values[dataIdx]);
        }
    }

    protected void WriteLong(long value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteLongs(long[] values)
    {
        if (values == null)
        {
            throw new IOException("null long[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteLong(values[dataIdx]);
        }
    }

    protected void WriteUlong(ulong value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteUlongs(ulong[] values)
    {
        if (values == null)
        {
            throw new IOException("null ulong[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteUlong(values[dataIdx]);
        }
    }

    protected void WriteFloat(float value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteFloats(float[] values)
    {
        if (values == null)
        {
            throw new IOException("null float[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteFloat(values[dataIdx]);
        }
    }

    protected void WriteDouble(double value)
    {
        WriteBigEndian(BitConverter.GetBytes(value));
    }

    protected void WriteDoubles(double[] values)
    {
        if (values == null)
        {
            throw new IOException("null double[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteDouble(values[dataIdx]);
        }
    }

    protected void WriteString(string value)
    {
        if(value == null)
        {
            throw new IOException("null string to serialize!");
        }

        short byteCount = (short)s_encoding.GetByteCount(value);
        byte[] bytes = s_encoding.GetBytes(value);

        WriteShort(byteCount);
        s_mStream.Write(bytes, 0, bytes.Length);
    }

    protected void WriteStrings(string[] values)
    {
        if (values == null)
        {
            throw new IOException("null string[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteString(values[dataIdx]);
        }
    }

    protected void WriteClass(ClassStream value)
    {
        if (value == null)
        {
            throw new IOException("null class to serialize!");
        }

        value.Write();
    }

    protected void WriteClasses(ClassStream[] values)
    {
        if (values == null)
        {
            throw new IOException("null class[] to serialize!");
        }

        short len = (short)values.Length;
        WriteShort(len);

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            WriteClass(values[dataIdx]);
        }
    }

    protected byte ReadByte()
    {
        return (byte)s_mStream.ReadByte();
    }

    protected byte[] ReadBytes()
    {
        short len = ReadShort();
        byte[] values = new byte[len];

        for(int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadByte();
        }

        return values;
    }

    protected bool ReadBool()
    {
        return ReadByte() != 0;
    }

    protected bool[] ReadBools()
    {
        short len = ReadShort();
        bool[] values = new bool[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadBool();
        }

        return values;
    }

    protected short ReadShort()
    {
        ReadByteToBuffer(SHORT_SIZE);
        return (short)((s_byteBuffer[0] << 8) | s_byteBuffer[1]);
    }

    protected short[] ReadShorts()
    {
        short len = ReadShort();
        short[] values = new short[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadShort();
        }

        return values;
    }

    protected ushort ReadUshort()
    {
        ReadByteToBuffer(USHORT_SIZE);
        return (ushort)(((s_byteBuffer[0] & 0xff) << 8) | (s_byteBuffer[1] & 0xff));
    }

    protected ushort[] ReadUshorts()
    {
        short len = ReadShort();
        ushort[] values = new ushort[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadUshort();
        }

        return values;
    }

    protected int ReadInt()
    {
        ReadByteToBuffer(INT_SIZE);
        return ((((s_byteBuffer[0] << 0x18) | (s_byteBuffer[1] << 0x10)) | (s_byteBuffer[2] << 8)) | s_byteBuffer[3]);
    }

    protected int[] ReadInts()
    {
        short len = ReadShort();
        int[] values = new int[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadInt();
        }

        return values;
    }

    protected uint ReadUint()
    {
        ReadByteToBuffer(UINT_SIZE);
        return (uint)((((s_byteBuffer[0] << 0x18) | (s_byteBuffer[1] << 0x10)) | (s_byteBuffer[2] << 8)) | s_byteBuffer[3]);
    }

    protected uint[] ReadUints()
    {
        short len = ReadShort();
        uint[] values = new uint[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadUint();
        }

        return values;
    }

    protected long ReadLong()
    {
        ReadByteToBuffer(LONG_SIZE);
        System.Array.Reverse(s_byteBuffer, 0, LONG_SIZE);
        return BitConverter.ToInt64(s_byteBuffer, 0);
    }

    protected long[] ReadLongs()
    {
        short len = ReadShort();
        long[] values = new long[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadLong();
        }

        return values;
    }

    protected ulong ReadUlong()
    {
        ReadByteToBuffer(ULONG_SIZE);
        System.Array.Reverse(s_byteBuffer, 0, ULONG_SIZE);
        return BitConverter.ToUInt64(s_byteBuffer, 0);
    }

    protected ulong[] ReadUlongs()
    {
        short len = ReadShort();
        ulong[] values = new ulong[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadUlong();
        }

        return values;
    }

    protected float ReadFloat()
    {
        ReadByteToBuffer(FLOAT_SIZE);
        int index = FLOAT_SIZE - 1;
        for (int i = 0; index >= 0; i++)
        {
            s_helpsBuffer[i] = s_byteBuffer[index];
            index--;
        }

        return BitConverter.ToSingle(s_helpsBuffer, 0);
    }

    protected float[] ReadFloats()
    {
        short len = ReadShort();
        float[] values = new float[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadFloat();
        }

        return values;
    }

    protected double ReadDouble()
    {
        this.ReadByteToBuffer(DOUBLE_SIZE);
        int index = DOUBLE_SIZE - 1;
        for (int i = 0; index >= 0; i++)
        {
            s_helpsBuffer[i] = s_byteBuffer[index];
            index--;
        }

        return BitConverter.ToDouble(s_helpsBuffer, 0);
    }

    protected double[] ReadDoubles()
    {
        short len = ReadShort();
        double[] values = new double[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadDouble();
        }

        return values;
    }

    protected string ReadString()
    {
        short len = ReadShort();
        byte[] bytes = new byte[len];
        ReadByteToBuffer(len, bytes);

        return s_encoding.GetString(bytes);
    }

    protected string[] ReadStrings()
    {
        short len = ReadShort();
        string[] values = new string[len];

        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            values[dataIdx] = ReadString();
        }

        return values;
    }

    protected T ReadClass<T>() where T : ClassStream, new ()
    {
        T t = new T();
        t.Read();

        return t;
    }

    protected T[] ReadClasses<T>() where T : ClassStream, new()
    {
        short len = ReadShort();
        T[] t = new T[len];
        for (int dataIdx = 0; dataIdx < len; ++dataIdx)
        {
            t[dataIdx] = ReadClass<T>();
        }

        return t;
    }
}