deukpack 1.0.0 → 1.0.2

package/dist/csharp/DpBinaryProtocol.cs

@@ -0,0 +1,579 @@
+// DpBinaryProtocol.cs - Extracted from DpProtocolLibrary.cs (DpBinaryProtocol class)
+
+using System;
+using System.IO;
+using System.Text;
+using System.Buffers;
+
+namespace DeukPack.Protocol {
+    /// <summary>
+    /// Binary protocol implementation with FastPacket-level optimization.
+    /// Unity compatible high-performance serialization.
+    /// </summary>
+    public class DpBinaryProtocol : DpProtocol, IDisposable
+    {
+        private readonly Stream _stream;
+        private readonly bool _strictRead;
+        private readonly bool _strictWrite;
+        private readonly bool _bigEndian;
+
+        // FastPacket-level optimizations
+        private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;
+        private byte[] _writeBuffer;
+        private int _writePosition;
+        private int _writeCapacity;
+
+        // Read buffer pooling
+        private byte[] _readBuffer;
+        private int _readPosition;
+        private int _readLength;
+        private const int READ_BUFFER_SIZE = 4096;
+        private const int MaxBinaryLength = 1024 * 1024 * 10; // 10MB
+
+        // Small buffer for primitive types (stackalloc-like optimization)
+        private const int SMALL_BUFFER_SIZE = 16;
+        private readonly byte[] _smallBuffer = new byte[SMALL_BUFFER_SIZE];
+
+        private readonly bool _directWrite;
+
+        /// <param name="bigEndian">true = Binary(Apache 호환), false = LEBinary</param>
+        public DpBinaryProtocol(Stream stream, bool bigEndian = true, bool strictRead = true, bool strictWrite = true, int initialBufferSize = 4096)
+        {
+            _stream = stream;
+            _bigEndian = bigEndian;
+            _strictRead = strictRead;
+            _strictWrite = strictWrite;
+
+            _directWrite = (stream is System.IO.MemoryStream);
+
+            if (!_directWrite && initialBufferSize > 0)
+            {
+                _writeBuffer = _bufferPool.Rent(initialBufferSize);
+                _writeCapacity = _writeBuffer.Length;
+            }
+            _writePosition = 0;
+
+            _readBuffer = _bufferPool.Rent(READ_BUFFER_SIZE);
+            _readPosition = 0;
+            _readLength = 0;
+        }
+
+        private void EnsureWriteBuffer(int additionalBytes)
+        {
+            if (_directWrite) return;
+            if (_writeBuffer == null || _writePosition + additionalBytes > _writeCapacity)
+            {
+                FlushWriteBuffer();
+                int newSize = Math.Max(_writePosition + additionalBytes, _writeCapacity * 2);
+                if (_writeBuffer != null)
+                {
+                    _bufferPool.Return(_writeBuffer);
+                }
+                _writeBuffer = _bufferPool.Rent(newSize);
+                _writeCapacity = _writeBuffer.Length;
+            }
+        }
+
+        private void FlushWriteBuffer()
+        {
+            if (_writeBuffer != null && _writePosition > 0)
+            {
+                _stream.Write(_writeBuffer, 0, _writePosition);
+                _writePosition = 0;
+            }
+        }
+
+        public void Dispose()
+        {
+            FlushWriteBuffer();
+            if (_writeBuffer != null)
+            {
+                _bufferPool.Return(_writeBuffer);
+                _writeBuffer = null;
+            }
+            if (_readBuffer != null)
+            {
+                _bufferPool.Return(_readBuffer);
+                _readBuffer = null;
+            }
+        }
+
+        public void WriteStructBegin(DpRecord structBegin)
+        {
+            // Binary protocol doesn't write struct names
+        }
+
+        public void WriteStructEnd()
+        {
+            // Binary protocol doesn't write struct end markers
+        }
+
+        /// <summary>
+        /// Flush all buffered writes to stream.
+        /// No-op when stream is MemoryStream (direct write mode).
+        /// </summary>
+        public void Flush()
+        {
+            if (!_directWrite) FlushWriteBuffer();
+        }
+
+        public void WriteFieldBegin(DpColumn field)
+        {
+            WriteByte((byte)field.Type);
+            WriteI16(field.ID);
+        }
+
+        public void WriteFieldEnd()
+        {
+            // Binary protocol doesn't write field end markers
+        }
+
+        public void WriteFieldStop()
+        {
+            WriteByte((byte)DpWireType.Stop);
+        }
+
+        public void WriteBool(bool b)
+        {
+            WriteByte(b ? (byte)1 : (byte)0);
+        }
+
+        public void WriteByte(byte b)
+        {
+            if (_directWrite) { _stream.WriteByte(b); return; }
+            EnsureWriteBuffer(1);
+            _writeBuffer[_writePosition++] = b;
+        }
+
+        public void WriteI16(short i16)
+        {
+            if (_directWrite)
+            {
+                if (_bigEndian)
+                {
+                    _smallBuffer[0] = (byte)((i16 >> 8) & 0xFF);
+                    _smallBuffer[1] = (byte)(i16 & 0xFF);
+                }
+                else
+                {
+                    _smallBuffer[0] = (byte)(i16 & 0xFF);
+                    _smallBuffer[1] = (byte)((i16 >> 8) & 0xFF);
+                }
+                _stream.Write(_smallBuffer, 0, 2);
+                return;
+            }
+            EnsureWriteBuffer(2);
+            WriteI16Optimized(i16);
+        }
+
+        public void WriteI32(int i32)
+        {
+            if (_directWrite)
+            {
+                if (_bigEndian)
+                {
+                    _smallBuffer[0] = (byte)((i32 >> 24) & 0xFF);
+                    _smallBuffer[1] = (byte)((i32 >> 16) & 0xFF);
+                    _smallBuffer[2] = (byte)((i32 >> 8) & 0xFF);
+                    _smallBuffer[3] = (byte)(i32 & 0xFF);
+                }
+                else
+                {
+                    _smallBuffer[0] = (byte)(i32 & 0xFF);
+                    _smallBuffer[1] = (byte)((i32 >> 8) & 0xFF);
+                    _smallBuffer[2] = (byte)((i32 >> 16) & 0xFF);
+                    _smallBuffer[3] = (byte)((i32 >> 24) & 0xFF);
+                }
+                _stream.Write(_smallBuffer, 0, 4);
+                return;
+            }
+            EnsureWriteBuffer(4);
+            WriteI32Optimized(i32);
+        }
+
+        public void WriteI64(long i64)
+        {
+            if (_directWrite)
+            {
+                if (_bigEndian)
+                {
+                    _smallBuffer[0] = (byte)((i64 >> 56) & 0xFF);
+                    _smallBuffer[1] = (byte)((i64 >> 48) & 0xFF);
+                    _smallBuffer[2] = (byte)((i64 >> 40) & 0xFF);
+                    _smallBuffer[3] = (byte)((i64 >> 32) & 0xFF);
+                    _smallBuffer[4] = (byte)((i64 >> 24) & 0xFF);
+                    _smallBuffer[5] = (byte)((i64 >> 16) & 0xFF);
+                    _smallBuffer[6] = (byte)((i64 >> 8) & 0xFF);
+                    _smallBuffer[7] = (byte)(i64 & 0xFF);
+                }
+                else
+                {
+                    _smallBuffer[0] = (byte)(i64 & 0xFF);
+                    _smallBuffer[1] = (byte)((i64 >> 8) & 0xFF);
+                    _smallBuffer[2] = (byte)((i64 >> 16) & 0xFF);
+                    _smallBuffer[3] = (byte)((i64 >> 24) & 0xFF);
+                    _smallBuffer[4] = (byte)((i64 >> 32) & 0xFF);
+                    _smallBuffer[5] = (byte)((i64 >> 40) & 0xFF);
+                    _smallBuffer[6] = (byte)((i64 >> 48) & 0xFF);
+                    _smallBuffer[7] = (byte)((i64 >> 56) & 0xFF);
+                }
+                _stream.Write(_smallBuffer, 0, 8);
+                return;
+            }
+            EnsureWriteBuffer(8);
+            WriteI64Optimized(i64);
+        }
+
+        public void WriteDouble(double d)
+        {
+            if (_directWrite)
+            {
+                WriteI64(BitConverter.DoubleToInt64Bits(d));
+                return;
+            }
+            EnsureWriteBuffer(8);
+            WriteDoubleOptimized(d);
+        }
+
+        public void WriteString(string s)
+        {
+            if (s == null)
+            {
+                WriteI32(0);
+                return;
+            }
+
+            int byteCount = Encoding.UTF8.GetByteCount(s);
+            WriteI32(byteCount);
+
+            if (byteCount > 0)
+            {
+                if (_directWrite)
+                {
+                    byte[] bytes = Encoding.UTF8.GetBytes(s);
+                    _stream.Write(bytes, 0, bytes.Length);
+                }
+                else
+                {
+                    EnsureWriteBuffer(byteCount);
+                    Encoding.UTF8.GetBytes(s, 0, s.Length, _writeBuffer, _writePosition);
+                    _writePosition += byteCount;
+                }
+            }
+        }
+
+        public void WriteBinary(byte[] b)
+        {
+            if (b == null)
+            {
+                WriteI32(0);
+                return;
+            }
+
+            WriteI32(b.Length);
+            if (b.Length > 0)
+            {
+                if (_directWrite)
+                {
+                    _stream.Write(b, 0, b.Length);
+                }
+                else
+                {
+                    EnsureWriteBuffer(b.Length);
+                    Array.Copy(b, 0, _writeBuffer, _writePosition, b.Length);
+                    _writePosition += b.Length;
+                }
+            }
+        }
+
+        private void WriteI16Optimized(short value)
+        {
+            if (_bigEndian)
+            {
+                _writeBuffer[_writePosition] = (byte)((value >> 8) & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)(value & 0xFF);
+            }
+            else
+            {
+                _writeBuffer[_writePosition] = (byte)(value & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)((value >> 8) & 0xFF);
+            }
+            _writePosition += 2;
+        }
+
+        private void WriteI32Optimized(int value)
+        {
+            if (_bigEndian)
+            {
+                _writeBuffer[_writePosition] = (byte)((value >> 24) & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)((value >> 16) & 0xFF);
+                _writeBuffer[_writePosition + 2] = (byte)((value >> 8) & 0xFF);
+                _writeBuffer[_writePosition + 3] = (byte)(value & 0xFF);
+            }
+            else
+            {
+                _writeBuffer[_writePosition] = (byte)(value & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)((value >> 8) & 0xFF);
+                _writeBuffer[_writePosition + 2] = (byte)((value >> 16) & 0xFF);
+                _writeBuffer[_writePosition + 3] = (byte)((value >> 24) & 0xFF);
+            }
+            _writePosition += 4;
+        }
+
+        private void WriteI64Optimized(long value)
+        {
+            if (_bigEndian)
+            {
+                _writeBuffer[_writePosition] = (byte)((value >> 56) & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)((value >> 48) & 0xFF);
+                _writeBuffer[_writePosition + 2] = (byte)((value >> 40) & 0xFF);
+                _writeBuffer[_writePosition + 3] = (byte)((value >> 32) & 0xFF);
+                _writeBuffer[_writePosition + 4] = (byte)((value >> 24) & 0xFF);
+                _writeBuffer[_writePosition + 5] = (byte)((value >> 16) & 0xFF);
+                _writeBuffer[_writePosition + 6] = (byte)((value >> 8) & 0xFF);
+                _writeBuffer[_writePosition + 7] = (byte)(value & 0xFF);
+            }
+            else
+            {
+                _writeBuffer[_writePosition] = (byte)(value & 0xFF);
+                _writeBuffer[_writePosition + 1] = (byte)((value >> 8) & 0xFF);
+                _writeBuffer[_writePosition + 2] = (byte)((value >> 16) & 0xFF);
+                _writeBuffer[_writePosition + 3] = (byte)((value >> 24) & 0xFF);
+                _writeBuffer[_writePosition + 4] = (byte)((value >> 32) & 0xFF);
+                _writeBuffer[_writePosition + 5] = (byte)((value >> 40) & 0xFF);
+                _writeBuffer[_writePosition + 6] = (byte)((value >> 48) & 0xFF);
+                _writeBuffer[_writePosition + 7] = (byte)((value >> 56) & 0xFF);
+            }
+            _writePosition += 8;
+        }
+
+        private void WriteDoubleOptimized(double value)
+        {
+            // Convert double to long and write as I64
+            long bits = BitConverter.DoubleToInt64Bits(value);
+            WriteI64Optimized(bits);
+        }
+
+        public void WriteListBegin(DpList list)
+        {
+            WriteByte((byte)list.ElementType);
+            WriteI32(list.Count);
+        }
+
+        public void WriteListEnd()
+        {
+            // Binary protocol doesn't write list end markers
+        }
+
+        public void WriteSetBegin(DpSet set)
+        {
+            WriteByte((byte)set.ElementType);
+            WriteI32(set.Count);
+        }
+
+        public void WriteSetEnd()
+        {
+            // Binary protocol doesn't write set end markers
+        }
+
+        public void WriteMapBegin(DpDict map)
+        {
+            WriteByte((byte)map.KeyType);
+            WriteByte((byte)map.ValueType);
+            WriteI32(map.Count);
+        }
+
+        public void WriteMapEnd()
+        {
+            // Binary protocol doesn't write map end markers
+        }
+
+        public DpRecord ReadStructBegin()
+        {
+            return new DpRecord();
+        }
+
+        public void ReadStructEnd()
+        {
+            // Binary protocol doesn't read struct end markers
+        }
+
+        public DpColumn ReadFieldBegin()
+        {
+            byte type = ReadByte();
+            if (type == (byte)DpWireType.Stop)
+            {
+                return new DpColumn("", DpWireType.Stop, 0);
+            }
+            short id = ReadI16();
+            return new DpColumn("", (DpWireType)type, id);
+        }
+
+        public void ReadFieldEnd()
+        {
+            // Binary protocol doesn't read field end markers
+        }
+
+        public bool ReadBool()
+        {
+            return ReadByte() != 0;
+        }
+
+        private void EnsureReadBuffer(int bytesNeeded)
+        {
+            if (_readPosition + bytesNeeded <= _readLength)
+                return;
+
+            int remaining = _readLength - _readPosition;
+
+            if (bytesNeeded > _readBuffer.Length)
+            {
+                var newBuf = _bufferPool.Rent(bytesNeeded + READ_BUFFER_SIZE);
+                if (remaining > 0)
+                    Array.Copy(_readBuffer, _readPosition, newBuf, 0, remaining);
+                _bufferPool.Return(_readBuffer);
+                _readBuffer = newBuf;
+            }
+            else if (remaining > 0)
+            {
+                Array.Copy(_readBuffer, _readPosition, _readBuffer, 0, remaining);
+            }
+            _readPosition = 0;
+            _readLength = remaining;
+
+            while (_readLength < bytesNeeded)
+            {
+                int bytesRead = _stream.Read(_readBuffer, _readLength, _readBuffer.Length - _readLength);
+                if (bytesRead == 0)
+                    throw new EndOfStreamException();
+                _readLength += bytesRead;
+            }
+        }
+
+        public byte ReadByte()
+        {
+            EnsureReadBuffer(1);
+            return _readBuffer[_readPosition++];
+        }
+
+        public short ReadI16()
+        {
+            EnsureReadBuffer(2);
+            return ReadI16Optimized();
+        }
+
+        public int ReadI32()
+        {
+            EnsureReadBuffer(4);
+            return ReadI32Optimized();
+        }
+
+        public long ReadI64()
+        {
+            EnsureReadBuffer(8);
+            return ReadI64Optimized();
+        }
+
+        public double ReadDouble()
+        {
+            // Convert from long bits
+            long bits = ReadI64();
+            return BitConverter.Int64BitsToDouble(bits);
+        }
+
+        public string ReadString()
+        {
+            int length = ReadI32();
+            if (length == 0)
+                return string.Empty;
+            if (length < 0 || length > MaxBinaryLength)
+                throw new InvalidOperationException($"Invalid string length: {length}");
+
+            EnsureReadBuffer(length);
+            string result = Encoding.UTF8.GetString(_readBuffer, _readPosition, length);
+            _readPosition += length;
+            return result;
+        }
+
+        public byte[] ReadBinary()
+        {
+            int length = ReadI32();
+            if (length == 0)
+                return new byte[0];
+            if (length < 0 || length > MaxBinaryLength)
+                throw new InvalidOperationException($"Invalid binary length: {length}");
+
+            EnsureReadBuffer(length);
+            byte[] result = new byte[length];
+            Array.Copy(_readBuffer, _readPosition, result, 0, length);
+            _readPosition += length;
+            return result;
+        }
+
+        // 엔디언: _bigEndian에 따라 BE / LE(네트워크 바이트 순서) 고정
+        private short ReadI16Optimized()
+        {
+            short value = _bigEndian
+                ? (short)((_readBuffer[_readPosition] << 8) | _readBuffer[_readPosition + 1])
+                : (short)(_readBuffer[_readPosition] | (_readBuffer[_readPosition + 1] << 8));
+            _readPosition += 2;
+            return value;
+        }
+
+        private int ReadI32Optimized()
+        {
+            int b0 = _readBuffer[_readPosition], b1 = _readBuffer[_readPosition + 1], b2 = _readBuffer[_readPosition + 2], b3 = _readBuffer[_readPosition + 3];
+            _readPosition += 4;
+            return _bigEndian
+                ? (b0 << 24) | (b1 << 16) | (b2 << 8) | b3
+                : (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
+        }
+
+        private long ReadI64Optimized()
+        {
+            long b0 = _readBuffer[_readPosition], b1 = _readBuffer[_readPosition + 1], b2 = _readBuffer[_readPosition + 2], b3 = _readBuffer[_readPosition + 3],
+                 b4 = _readBuffer[_readPosition + 4], b5 = _readBuffer[_readPosition + 5], b6 = _readBuffer[_readPosition + 6], b7 = _readBuffer[_readPosition + 7];
+            _readPosition += 8;
+            return _bigEndian
+                ? ((long)b0 << 56) | ((long)b1 << 48) | ((long)b2 << 40) | ((long)b3 << 32) | ((long)b4 << 24) | ((long)b5 << 16) | ((long)b6 << 8) | b7
+                : ((long)b7 << 56) | ((long)b6 << 48) | ((long)b5 << 40) | ((long)b4 << 32) | ((long)b3 << 24) | ((long)b2 << 16) | ((long)b1 << 8) | b0;
+        }
+
+        public DpList ReadListBegin()
+        {
+            byte elementType = ReadByte();
+            int count = ReadI32();
+            return new DpList { ElementType = (DpWireType)elementType, Count = count };
+        }
+
+        public void ReadListEnd()
+        {
+            // Binary protocol doesn't read list end markers
+        }
+
+        public DpSet ReadSetBegin()
+        {
+            byte elementType = ReadByte();
+            int count = ReadI32();
+            return new DpSet { ElementType = (DpWireType)elementType, Count = count };
+        }
+
+        public void ReadSetEnd()
+        {
+            // Binary protocol doesn't read set end markers
+        }
+
+        public DpDict ReadMapBegin()
+        {
+            byte keyType = ReadByte();
+            byte valueType = ReadByte();
+            int count = ReadI32();
+            return new DpDict { KeyType = (DpWireType)keyType, ValueType = (DpWireType)valueType, Count = count };
+        }
+
+        public void ReadMapEnd()
+        {
+            // Binary protocol doesn't read map end markers
+        }
+    }
+}