test[golang]: compatible field of inside protocol class

protocol/src/test/go/protocol/NormalObject.go

@@ -1,127 +0,0 @@
-package protocol
-
-type NormalObject struct {
-	a    int8
-	aaa  []int8
-	b    int16
-	c    int
-	d    int64
-	e    float32
-	f    float64
-	g    bool
-	jj   string
-	kk   ObjectA
-	l    []int
-	ll   []int64
-	lll  []ObjectA
-	llll []string
-	m    map[int]string
-	mm   map[int]ObjectA
-	s    []int
-	ssss []string
-}
-
-func (protocol NormalObject) protocolId() int16 {
-	return 101
-}
-
-func (protocol NormalObject) write(buffer *ByteBuffer, packet any) {
-	if buffer.WritePacketFlag(packet) {
-		return
-	}
-	var message = packet.(*NormalObject)
-	buffer.WriteByte(message.a)
-	buffer.WriteByteArray(message.aaa)
-	buffer.WriteShort(message.b)
-	buffer.WriteInt(message.c)
-	buffer.WriteLong(message.d)
-	buffer.WriteFloat(message.e)
-	buffer.WriteDouble(message.f)
-	buffer.WriteBool(message.g)
-	buffer.WriteString(message.jj)
-	buffer.WritePacket(&message.kk, 102)
-	buffer.WriteIntArray(message.l)
-	buffer.WriteLongArray(message.ll)
-	if message.lll == nil {
-		buffer.WriteInt(0)
-	} else {
-		buffer.WriteInt(len(message.lll))
-		var length0 = len(message.lll)
-		for i1 := 0; i1 < length0; i1++ {
-			var element2 = message.lll[i1]
-			buffer.WritePacket(&element2, 102)
-		}
-	}
-	buffer.WriteStringArray(message.llll)
-	buffer.WriteIntStringMap(message.m)
-	if (message.mm == nil) || (len(message.mm) == 0) {
-		buffer.WriteInt(0)
-	} else {
-		buffer.WriteInt(len(message.mm))
-		for keyElement4, valueElement5 := range message.mm {
-			buffer.WriteInt(keyElement4)
-			buffer.WritePacket(&valueElement5, 102)
-		}
-	}
-	buffer.WriteIntArray(message.s)
-	buffer.WriteStringArray(message.ssss)
-}
-
-func (protocol NormalObject) read(buffer *ByteBuffer) any {
-	var packet = new(NormalObject)
-	if !buffer.ReadBool() {
-		return packet
-	}
-	var result6 = buffer.ReadByte()
-	packet.a = result6
-	var array7 = buffer.ReadByteArray()
-	packet.aaa = array7
-	var result8 = buffer.ReadShort()
-	packet.b = result8
-	var result9 = buffer.ReadInt()
-	packet.c = result9
-	var result10 = buffer.ReadLong()
-	packet.d = result10
-	var result11 = buffer.ReadFloat()
-	packet.e = result11
-	var result12 = buffer.ReadDouble()
-	packet.f = result12
-	var result13 = buffer.ReadBool()
-	packet.g = result13
-	var result14 = buffer.ReadString()
-	packet.jj = result14
-	var result15 = *buffer.ReadPacket(102).(*ObjectA)
-	packet.kk = result15
-	var list16 = buffer.ReadIntArray()
-	packet.l = list16
-	var list17 = buffer.ReadLongArray()
-	packet.ll = list17
-	var size20 = buffer.ReadInt()
-	var result18 = make([]ObjectA, size20)
-	if size20 > 0 {
-		for index19 := 0; index19 < size20; index19++ {
-			var result21 = *buffer.ReadPacket(102).(*ObjectA)
-			result18[index19] = result21
-		}
-	}
-	packet.lll = result18
-	var list22 = buffer.ReadStringArray()
-	packet.llll = list22
-	var map23 = buffer.ReadIntStringMap()
-	packet.m = map23
-	var size25 = buffer.ReadInt()
-	var result24 = make(map[int]ObjectA)
-	if size25 > 0 {
-		for index26 := 0; index26 < size25; index26++ {
-			var result27 = buffer.ReadInt()
-			var result28 = *buffer.ReadPacket(102).(*ObjectA)
-			result24[result27] = result28
-		}
-	}
-	packet.mm = result24
-	var set29 = buffer.ReadIntArray()
-	packet.s = set29
-	var set30 = buffer.ReadStringArray()
-	packet.ssss = set30
-	return packet
-}

protocol/src/test/go/protocol/ObjectA.go

@@ -1,35 +0,0 @@
-package protocol
-
-type ObjectA struct {
-	a       int
-	m       map[int]string
-	objectB ObjectB
-}
-
-func (protocol ObjectA) protocolId() int16 {
-	return 102
-}
-
-func (protocol ObjectA) write(buffer *ByteBuffer, packet any) {
-	if buffer.WritePacketFlag(packet) {
-		return
-	}
-	var message = packet.(*ObjectA)
-	buffer.WriteInt(message.a)
-	buffer.WriteIntStringMap(message.m)
-	buffer.WritePacket(&message.objectB, 103)
-}
-
-func (protocol ObjectA) read(buffer *ByteBuffer) any {
-	var packet = new(ObjectA)
-	if !buffer.ReadBool() {
-		return packet
-	}
-	var result0 = buffer.ReadInt()
-	packet.a = result0
-	var map1 = buffer.ReadIntStringMap()
-	packet.m = map1
-	var result2 = *buffer.ReadPacket(103).(*ObjectB)
-	packet.objectB = result2
-	return packet
-}

protocol/src/test/go/protocol/ObjectB.go

@@ -1,27 +0,0 @@
-package protocol
-
-type ObjectB struct {
-	flag bool
-}
-
-func (protocol ObjectB) protocolId() int16 {
-	return 103
-}
-
-func (protocol ObjectB) write(buffer *ByteBuffer, packet any) {
-	if buffer.WritePacketFlag(packet) {
-		return
-	}
-	var message = packet.(*ObjectB)
-	buffer.WriteBool(message.flag)
-}
-
-func (protocol ObjectB) read(buffer *ByteBuffer) any {
-	var packet = new(ObjectB)
-	if !buffer.ReadBool() {
-		return packet
-	}
-	var result0 = buffer.ReadBool()
-	packet.flag = result0
-	return packet
-}

protocol/src/test/go/protocol/ProtocolManager.go

@@ -1,8 +0,0 @@
-package protocol
-
-func init() {
-	Protocols[101] = new(NormalObject)
-	Protocols[102] = new(ObjectA)
-	Protocols[103] = new(ObjectB)
-	Protocols[104] = new(SimpleObject)
-}

protocol/src/test/go/protocol/SimpleObject.go

@@ -1,31 +0,0 @@
-package protocol
-
-type SimpleObject struct {
-	c int
-	g bool
-}
-
-func (protocol SimpleObject) protocolId() int16 {
-	return 104
-}
-
-func (protocol SimpleObject) write(buffer *ByteBuffer, packet any) {
-	if buffer.WritePacketFlag(packet) {
-		return
-	}
-	var message = packet.(*SimpleObject)
-	buffer.WriteInt(message.c)
-	buffer.WriteBool(message.g)
-}
-
-func (protocol SimpleObject) read(buffer *ByteBuffer) any {
-	var packet = new(SimpleObject)
-	if !buffer.ReadBool() {
-		return packet
-	}
-	var result0 = buffer.ReadInt()
-	packet.c = result0
-	var result1 = buffer.ReadBool()
-	packet.g = result1
-	return packet
-}

protocol/src/test/go/zfoogo/ByteBuffer.go

@@ -18,6 +18,29 @@ type ByteBuffer struct {
 	readIndex  int
 }
 
+func (byteBuffer *ByteBuffer) AdjustPadding(predictionLength int, beforeWriteIndex int) {
+	// 因为写入的是可变长的int，如果预留的位置过多，则清除多余的位置
+	var currentWriteIndex = byteBuffer.WriteOffset()
+	var predictionCount = byteBuffer.WriteIntCount(int32(predictionLength))
+	var length = currentWriteIndex - beforeWriteIndex - predictionCount
+	var lengthCount = byteBuffer.WriteIntCount(int32(length))
+	var padding = lengthCount - predictionCount
+	if padding == 0 {
+		byteBuffer.SetWriteOffset(beforeWriteIndex)
+		byteBuffer.WriteInt(length)
+		byteBuffer.SetWriteOffset(currentWriteIndex)
+	} else {
+		var byteArray = byteBuffer.buffer[(currentWriteIndex - length):currentWriteIndex]
+		byteBuffer.SetWriteOffset(beforeWriteIndex)
+		byteBuffer.WriteInt(length)
+		byteBuffer.WriteUBytes(byteArray)
+	}
+}
+
+func (byteBuffer *ByteBuffer) CompatibleRead(beforeReadIndex int, length int) bool {
+	return length != -1 && byteBuffer.readIndex < length+beforeReadIndex
+}
+
 // -------------------------------------------------get/set-------------------------------------------------
 func (byteBuffer *ByteBuffer) WriteOffset() int {
 	return byteBuffer.writeIndex
@@ -31,6 +54,10 @@ func (byteBuffer *ByteBuffer) SetWriteOffset(writeIndex int) {
 	byteBuffer.writeIndex = writeIndex
 }
 
+func (byteBuffer *ByteBuffer) ReadOffset() int {
+	return byteBuffer.readIndex
+}
+
 func (byteBuffer *ByteBuffer) SetReadOffset(readIndex int) {
 	if readIndex > byteBuffer.writeIndex {
 		var error = fmt.Sprintf("readIndex:[{%d}] out of bounds exception: readerIndex:[{%d}] , writerIndex:[{%d}] (expected: 0 <= readerIndex <= writerIndex <= capacity:[{%d}])", readIndex, byteBuffer.readIndex, byteBuffer.writeIndex, len(byteBuffer.buffer))
@@ -171,7 +198,11 @@ func (byteBuffer *ByteBuffer) WriteRawInt32(intValue int32) {
 }
 
 func (byteBuffer *ByteBuffer) ReadRawInt32() int32 {
-	return int32(uint32(byteBuffer.ReadUByte())<<24 | uint32(byteBuffer.ReadUByte())<<16 | uint32(byteBuffer.ReadUByte())<<8 | uint32(byteBuffer.ReadUByte()))
+	var byteArray = byteBuffer.ReadUBytes(4)
+	bytesBuffer := bytes.NewBuffer(byteArray)
+	var value int32
+	binary.Read(bytesBuffer, binary.BigEndian, &value)
+	return value
 }
 
 func (byteBuffer *ByteBuffer) WriteInt(intValue int) {
@@ -185,6 +216,24 @@ func (byteBuffer *ByteBuffer) ReadInt() int {
 	return int(byteBuffer.ReadInt32())
 }
 
+func (byteBuffer *ByteBuffer) WriteIntCount(intValue int32) int {
+	var value uint32 = uint32(((intValue << 1) ^ (intValue >> 31)))
+	// 右移操作>>是带符号右移
+	if value>>7 == 0 {
+		return 1
+	}
+	if value>>14 == 0 {
+		return 2
+	}
+	if value>>21 == 0 {
+		return 3
+	}
+	if value>>28 == 0 {
+		return 4
+	}
+	return 5
+}
+
 func (byteBuffer *ByteBuffer) WriteInt32(intValue int32) {
 	var value uint32 = uint32(((intValue << 1) ^ (intValue >> 31)))
 	// 右移操作>>是带符号右移
@@ -426,12 +475,6 @@ func (byteBuffer *ByteBuffer) ReadChar() string {
 	return byteBuffer.ReadString()
 }
 
-func (byteBuffer *ByteBuffer) WritePacketFlag(packet any) bool {
-	var flag = packet == nil
-	byteBuffer.WriteBool(!flag)
-	return flag
-}
-
 func (byteBuffer *ByteBuffer) WritePacket(packet any, protocolId int16) {
 	var protocolRegistration = GetProtocol(protocolId)
 	protocolRegistration.write(byteBuffer, packet)
@@ -444,7 +487,7 @@ func (byteBuffer *ByteBuffer) ReadPacket(protocolId int16) any {
 
 // -------------------------------------------------IProtocolRegistration-------------------------------------------------
 type IProtocolRegistration interface {
-	protocolId() int16
+	ProtocolId() int16
 
 	write(buffer *ByteBuffer, packet any)
 
@@ -459,7 +502,7 @@ func GetProtocol(protocolId int16) IProtocolRegistration {
 }
 
 func Write(buffer *ByteBuffer, packet any) {
-	var protocolId = packet.(IProtocolRegistration).protocolId()
+	var protocolId = packet.(IProtocolRegistration).ProtocolId()
 	buffer.WriteShort(protocolId)
 	var protocolRegistration = GetProtocol(protocolId)
 	protocolRegistration.write(buffer, packet)

protocol/src/test/go/zfoogo/EmptyObject.go

@@ -0,0 +1,30 @@
+package protocol
+
+type EmptyObject struct {
+	
+}
+
+func (protocol EmptyObject) ProtocolId() int16 {
+	return 0
+}
+
+func (protocol EmptyObject) write(buffer *ByteBuffer, packet any) {
+	if packet == nil {
+	    buffer.WriteInt(0)
+		return
+	}
+	buffer.WriteInt(-1)
+}
+
+func (protocol EmptyObject) read(buffer *ByteBuffer) any {
+	var packet = new(EmptyObject)
+	var length = buffer.ReadInt()
+	if length == 0 {
+		return packet
+	}
+	var beforeReadIndex = buffer.ReadOffset()
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}

protocol/src/test/go/zfoogo/NormalObject.go

@@ -0,0 +1,142 @@
+package protocol
+
+type NormalObject struct {
+	A int8
+    Aaa []int8
+    B int16
+    C int
+    D int64
+    E float32
+    F float64
+    G bool
+    Jj string
+    Kk ObjectA
+    L []int
+    Ll []int64
+    Lll []ObjectA
+    Llll []string
+    M map[int]string
+    Mm map[int]ObjectA
+    S []int
+    Ssss []string
+    OutCompatibleValue int
+}
+
+func (protocol NormalObject) ProtocolId() int16 {
+	return 101
+}
+
+func (protocol NormalObject) write(buffer *ByteBuffer, packet any) {
+	if packet == nil {
+	    buffer.WriteInt(0)
+		return
+	}
+	var message = packet.(*NormalObject)
+	var beforeWriteIndex = buffer.WriteOffset()
+    buffer.WriteInt(854)
+    buffer.WriteByte(message.A)
+    buffer.WriteByteArray(message.Aaa)
+    buffer.WriteShort(message.B)
+    buffer.WriteInt(message.C)
+    buffer.WriteLong(message.D)
+    buffer.WriteFloat(message.E)
+    buffer.WriteDouble(message.F)
+    buffer.WriteBool(message.G)
+    buffer.WriteString(message.Jj)
+    buffer.WritePacket(&message.Kk, 102)
+    buffer.WriteIntArray(message.L)
+    buffer.WriteLongArray(message.Ll)
+    if message.Lll == nil {
+        buffer.WriteInt(0)
+    } else {
+        buffer.WriteInt(len(message.Lll))
+        var length0 = len(message.Lll)
+        for i1 := 0; i1 < length0; i1++ {
+            var element2 = message.Lll[i1]
+            buffer.WritePacket(&element2, 102)
+        }
+    }
+    buffer.WriteStringArray(message.Llll)
+    buffer.WriteIntStringMap(message.M)
+    if (message.Mm == nil) || (len(message.Mm) == 0) {
+        buffer.WriteInt(0)
+    } else {
+        buffer.WriteInt(len(message.Mm))
+        for keyElement4, valueElement5 := range message.Mm {
+            buffer.WriteInt(keyElement4)
+            buffer.WritePacket(&valueElement5, 102)
+        }
+    }
+    buffer.WriteIntArray(message.S)
+    buffer.WriteStringArray(message.Ssss)
+    buffer.WriteInt(message.OutCompatibleValue)
+    buffer.AdjustPadding(854, beforeWriteIndex)
+}
+
+func (protocol NormalObject) read(buffer *ByteBuffer) any {
+	var packet = new(NormalObject)
+	var length = buffer.ReadInt()
+	if length == 0 {
+		return packet
+	}
+	var beforeReadIndex = buffer.ReadOffset()
+	var result6 = buffer.ReadByte()
+    packet.A = result6
+    var array7 = buffer.ReadByteArray()
+    packet.Aaa = array7
+    var result8 = buffer.ReadShort()
+    packet.B = result8
+    var result9 = buffer.ReadInt()
+    packet.C = result9
+    var result10 = buffer.ReadLong()
+    packet.D = result10
+    var result11 = buffer.ReadFloat()
+    packet.E = result11
+    var result12 = buffer.ReadDouble()
+    packet.F = result12
+    var result13 = buffer.ReadBool()
+    packet.G = result13
+    var result14 = buffer.ReadString()
+    packet.Jj = result14
+    var result15 = *buffer.ReadPacket(102).(*ObjectA)
+    packet.Kk = result15
+    var list16 = buffer.ReadIntArray()
+    packet.L = list16
+    var list17 = buffer.ReadLongArray()
+    packet.Ll = list17
+    var size20 = buffer.ReadInt()
+    var result18 = make([]ObjectA, size20)
+    if size20 > 0 {
+        for index19 := 0; index19 < size20; index19++ {
+            var result21 = *buffer.ReadPacket(102).(*ObjectA)
+            result18[index19] = result21
+        }
+    }
+    packet.Lll = result18
+    var list22 = buffer.ReadStringArray()
+    packet.Llll = list22
+    var map23 = buffer.ReadIntStringMap()
+    packet.M = map23
+    var size25 = buffer.ReadInt()
+    var result24 = make(map[int]ObjectA)
+    if size25 > 0 {
+        for index26 := 0; index26 < size25; index26++ {
+            var result27 = buffer.ReadInt()
+            var result28 = *buffer.ReadPacket(102).(*ObjectA)
+            result24[result27] = result28
+        }
+    }
+    packet.Mm = result24
+    var set29 = buffer.ReadIntArray()
+    packet.S = set29
+    var set30 = buffer.ReadStringArray()
+    packet.Ssss = set30
+    if buffer.CompatibleRead(beforeReadIndex, length) {
+        var result31 = buffer.ReadInt()
+        packet.OutCompatibleValue = result31
+    }
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}

protocol/src/test/go/zfoogo/ObjectA.go

@@ -0,0 +1,50 @@
+package protocol
+
+type ObjectA struct {
+	A int
+    M map[int]string
+    ObjectB ObjectB
+    InnerCompatibleValue int
+}
+
+func (protocol ObjectA) ProtocolId() int16 {
+	return 102
+}
+
+func (protocol ObjectA) write(buffer *ByteBuffer, packet any) {
+	if packet == nil {
+	    buffer.WriteInt(0)
+		return
+	}
+	var message = packet.(*ObjectA)
+	var beforeWriteIndex = buffer.WriteOffset()
+    buffer.WriteInt(201)
+    buffer.WriteInt(message.A)
+    buffer.WriteIntStringMap(message.M)
+    buffer.WritePacket(&message.ObjectB, 103)
+    buffer.WriteInt(message.InnerCompatibleValue)
+    buffer.AdjustPadding(201, beforeWriteIndex)
+}
+
+func (protocol ObjectA) read(buffer *ByteBuffer) any {
+	var packet = new(ObjectA)
+	var length = buffer.ReadInt()
+	if length == 0 {
+		return packet
+	}
+	var beforeReadIndex = buffer.ReadOffset()
+	var result0 = buffer.ReadInt()
+    packet.A = result0
+    var map1 = buffer.ReadIntStringMap()
+    packet.M = map1
+    var result2 = *buffer.ReadPacket(103).(*ObjectB)
+    packet.ObjectB = result2
+    if buffer.CompatibleRead(beforeReadIndex, length) {
+        var result3 = buffer.ReadInt()
+        packet.InnerCompatibleValue = result3
+    }
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}

protocol/src/test/go/zfoogo/ObjectB.go

@@ -0,0 +1,42 @@
+package protocol
+
+type ObjectB struct {
+	Flag bool
+    InnerCompatibleValue int
+}
+
+func (protocol ObjectB) ProtocolId() int16 {
+	return 103
+}
+
+func (protocol ObjectB) write(buffer *ByteBuffer, packet any) {
+	if packet == nil {
+	    buffer.WriteInt(0)
+		return
+	}
+	var message = packet.(*ObjectB)
+	var beforeWriteIndex = buffer.WriteOffset()
+    buffer.WriteInt(4)
+    buffer.WriteBool(message.Flag)
+    buffer.WriteInt(message.InnerCompatibleValue)
+    buffer.AdjustPadding(4, beforeWriteIndex)
+}
+
+func (protocol ObjectB) read(buffer *ByteBuffer) any {
+	var packet = new(ObjectB)
+	var length = buffer.ReadInt()
+	if length == 0 {
+		return packet
+	}
+	var beforeReadIndex = buffer.ReadOffset()
+	var result0 = buffer.ReadBool()
+    packet.Flag = result0
+    if buffer.CompatibleRead(beforeReadIndex, length) {
+        var result1 = buffer.ReadInt()
+        packet.InnerCompatibleValue = result1
+    }
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}

protocol/src/test/go/zfoogo/ProtocolManager.go

@@ -0,0 +1,10 @@
+package protocol
+
+func init() {
+	Protocols[0] = new(EmptyObject)
+    Protocols[1] = new(VeryBigObject)
+    Protocols[101] = new(NormalObject)
+    Protocols[102] = new(ObjectA)
+    Protocols[103] = new(ObjectB)
+    Protocols[104] = new(SimpleObject)
+}

protocol/src/test/go/zfoogo/SimpleObject.go

@@ -0,0 +1,38 @@
+package protocol
+
+type SimpleObject struct {
+	C int
+    G bool
+}
+
+func (protocol SimpleObject) ProtocolId() int16 {
+	return 104
+}
+
+func (protocol SimpleObject) write(buffer *ByteBuffer, packet any) {
+	if packet == nil {
+	    buffer.WriteInt(0)
+		return
+	}
+	var message = packet.(*SimpleObject)
+	buffer.WriteInt(-1)
+    buffer.WriteInt(message.C)
+    buffer.WriteBool(message.G)
+}
+
+func (protocol SimpleObject) read(buffer *ByteBuffer) any {
+	var packet = new(SimpleObject)
+	var length = buffer.ReadInt()
+	if length == 0 {
+		return packet
+	}
+	var beforeReadIndex = buffer.ReadOffset()
+	var result0 = buffer.ReadInt()
+    packet.C = result0
+    var result1 = buffer.ReadBool()
+    packet.G = result1
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}

protocol/src/test/go/zfoogo/buffer_test.go

@@ -123,14 +123,20 @@ func stringTest(buffer *ByteBuffer) {
 }
 
 func packetTest() {
-	bytes, _ := os.ReadFile("../../resources/NormalObject.bytes")
+	//bytes, _ := os.ReadFile("D:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-no-compatible.bytes")
+	//bytes, _ := os.ReadFile("D:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-compatible.bytes")
+	//bytes, _ := os.ReadFile("D:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-inner-compatible.bytes")
+	//bytes, _ := os.ReadFile("D:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-inner-compatible.bytes")
+	bytes, _ := os.ReadFile("D:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-inner-inner-compatible.bytes")
 	var buffer = new(ByteBuffer)
 	buffer.WriteUBytes(bytes)
 	var packet = Read(buffer)
 	fmt.Println(packet)
+	fmt.Println("source size ", buffer.WriteOffset())
 
 	buffer.Clear()
 	Write(buffer, packet)
 	var newPacket = Read(buffer)
+	fmt.Println("target size ", buffer.WriteOffset())
 	fmt.Println(newPacket)
 }