test[Golang]: Golang protocol test

protocol/src/test/go/go.mod

@@ -1,3 +0,0 @@
-module protocol
-
-go 1.19

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

@@ -1,30 +0,0 @@
-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

@@ -1,142 +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
-    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

@@ -1,50 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,38 +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 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/golang/buffer_test.go

@@ -10,13 +10,14 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 
-package protocol
+package main
 
 import (
 	"fmt"
 	"math"
 	"os"
 	"testing"
+	"zfoogo/zfoogo"
 )
 
 func assert(flag bool) {
@@ -26,7 +27,7 @@ func assert(flag bool) {
 }
 
 func TestByteBuffer(t *testing.T) {
-	var buffer = new(ByteBuffer)
+	var buffer = new(zfoogo.ByteBuffer)
 	boolTest(buffer)
 	byteTest(buffer)
 	bytesTest(buffer)
@@ -39,7 +40,7 @@ func TestByteBuffer(t *testing.T) {
 	packetTest()
 }
 
-func boolTest(buffer *ByteBuffer) {
+func boolTest(buffer *zfoogo.ByteBuffer) {
 	var value = true
 	buffer.WriteBool(value)
 	assert(buffer.ReadBool() == value)
@@ -48,7 +49,7 @@ func boolTest(buffer *ByteBuffer) {
 	assert(buffer.ReadBool() == value)
 }
 
-func byteTest(buffer *ByteBuffer) {
+func byteTest(buffer *zfoogo.ByteBuffer) {
 	var byteValues = []byte{127, 0, 255}
 	for _, value := range byteValues {
 		buffer.WriteUByte(value)
@@ -62,7 +63,7 @@ func byteTest(buffer *ByteBuffer) {
 	}
 }
 
-func bytesTest(buffer *ByteBuffer) {
+func bytesTest(buffer *zfoogo.ByteBuffer) {
 	var bytes = []byte{127, 0, 255}
 	buffer.WriteUBytes(bytes)
 	var readBytes = buffer.ReadUBytes(len(bytes))
@@ -71,7 +72,7 @@ func bytesTest(buffer *ByteBuffer) {
 	}
 }
 
-func shortTest(buffer *ByteBuffer) {
+func shortTest(buffer *zfoogo.ByteBuffer) {
 	var shortValues = []int16{-32768, -100, -2, -1, 0, 1, 2, 100, 32767}
 	for _, value := range shortValues {
 		buffer.WriteShort(value)
@@ -80,7 +81,7 @@ func shortTest(buffer *ByteBuffer) {
 	}
 }
 
-func intTest(buffer *ByteBuffer) {
+func intTest(buffer *zfoogo.ByteBuffer) {
 	var intValues = []int{math.MinInt32, -99999999, -32768, -100, -2, -1, 0, 1, 2, 100, 32767, 99999999, math.MaxInt32}
 	for _, value := range intValues {
 		buffer.WriteInt(value)
@@ -89,7 +90,7 @@ func intTest(buffer *ByteBuffer) {
 	}
 }
 
-func longTest(buffer *ByteBuffer) {
+func longTest(buffer *zfoogo.ByteBuffer) {
 	var longValues = []int64{math.MinInt64, -99999999, -32768, -100, -2, -1, 0, 1, 2, 100, 32767, 99999999, math.MaxInt64}
 	for _, value := range longValues {
 		buffer.WriteLong(value)
@@ -98,7 +99,7 @@ func longTest(buffer *ByteBuffer) {
 	}
 }
 
-func floatTest(buffer *ByteBuffer) {
+func floatTest(buffer *zfoogo.ByteBuffer) {
 	var floatValues = []float32{-12345678.12345678, -1234.5678, -100, -2, -1, 0, 1, 2, 100, 1234.5678, math.MaxFloat32}
 	for _, value := range floatValues {
 		buffer.WriteFloat(value)
@@ -107,7 +108,7 @@ func floatTest(buffer *ByteBuffer) {
 	}
 }
 
-func doubleTest(buffer *ByteBuffer) {
+func doubleTest(buffer *zfoogo.ByteBuffer) {
 	var doubleValues = []float64{-12345678.12345678, -1234.5678, -100, -2, -1, 0, 1, 2, 100, 1234.5678, math.MaxFloat64}
 	for _, value := range doubleValues {
 		buffer.WriteDouble(value)
@@ -116,7 +117,7 @@ func doubleTest(buffer *ByteBuffer) {
 	}
 }
 
-func stringTest(buffer *ByteBuffer) {
+func stringTest(buffer *zfoogo.ByteBuffer) {
 	var value = "hello world!"
 	buffer.WriteString(value)
 	assert(buffer.ReadString() == value)
@@ -127,16 +128,16 @@ func packetTest() {
 	//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)
+	bytes, _ := os.ReadFile("D:\\Project\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-inner-inner-compatible.bytes")
+	var buffer = new(zfoogo.ByteBuffer)
 	buffer.WriteUBytes(bytes)
-	var packet = Read(buffer)
+	var packet = zfoogo.Read(buffer)
 	fmt.Println(packet)
 	fmt.Println("source size ", buffer.WriteOffset())
 
 	buffer.Clear()
-	Write(buffer, packet)
-	var newPacket = Read(buffer)
+	zfoogo.Write(buffer, packet)
+	var newPacket = zfoogo.Read(buffer)
 	fmt.Println("target size ", buffer.WriteOffset())
 	fmt.Println(newPacket)
 }

protocol/src/test/golang/go.mod

@@ -0,0 +1,3 @@
+module zfoogo
+
+go 1.19

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

@@ -1,4 +1,4 @@
-package protocol
+package zfoogo
 
 import (
 	"bytes"

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

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

protocol/src/test/golang/zfoogo/Protocols.go

@@ -0,0 +1,301 @@
+package zfoogo
+
+
+type EmptyObject struct {
+	
+}
+
+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
+	OutCompatibleValue2 int
+}
+
+type ObjectA struct {
+	A int
+	M map[int]string
+	ObjectB ObjectB
+	InnerCompatibleValue int
+}
+
+type ObjectB struct {
+	Flag bool
+	InnerCompatibleValue int
+}
+
+type SimpleObject struct {
+	C int
+	G bool
+}
+
+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
+}
+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(857)
+	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.WriteInt(message.OutCompatibleValue2)
+	buffer.AdjustPadding(857, 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 result0 = buffer.ReadByte()
+	packet.A = result0
+	var array1 = buffer.ReadByteArray()
+	packet.Aaa = array1
+	var result2 = buffer.ReadShort()
+	packet.B = result2
+	var result3 = buffer.ReadInt()
+	packet.C = result3
+	var result4 = buffer.ReadLong()
+	packet.D = result4
+	var result5 = buffer.ReadFloat()
+	packet.E = result5
+	var result6 = buffer.ReadDouble()
+	packet.F = result6
+	var result7 = buffer.ReadBool()
+	packet.G = result7
+	var result8 = buffer.ReadString()
+	packet.Jj = result8
+	var result9 = *buffer.ReadPacket(102).(*ObjectA)
+	packet.Kk = result9
+	var list10 = buffer.ReadIntArray()
+	packet.L = list10
+	var list11 = buffer.ReadLongArray()
+	packet.Ll = list11
+	var size14 = buffer.ReadInt()
+	var result12 = make([]ObjectA, size14)
+	if size14 > 0 {
+	    for index13 := 0; index13 < size14; index13++ {
+	        var result15 = *buffer.ReadPacket(102).(*ObjectA)
+	        result12[index13] = result15
+	    }
+	}
+	packet.Lll = result12
+	var list16 = buffer.ReadStringArray()
+	packet.Llll = list16
+	var map17 = buffer.ReadIntStringMap()
+	packet.M = map17
+	var size19 = buffer.ReadInt()
+	var result18 = make(map[int]ObjectA)
+	if size19 > 0 {
+	    for index20 := 0; index20 < size19; index20++ {
+	        var result21 = buffer.ReadInt()
+	        var result22 = *buffer.ReadPacket(102).(*ObjectA)
+	        result18[result21] = result22
+	    }
+	}
+	packet.Mm = result18
+	var set23 = buffer.ReadIntArray()
+	packet.S = set23
+	var set24 = buffer.ReadStringArray()
+	packet.Ssss = set24
+	if buffer.CompatibleRead(beforeReadIndex, length) {
+	    var result25 = buffer.ReadInt()
+	    packet.OutCompatibleValue = result25
+	}
+	if buffer.CompatibleRead(beforeReadIndex, length) {
+	    var result26 = buffer.ReadInt()
+	    packet.OutCompatibleValue2 = result26
+	}
+	if length > 0 {
+        buffer.SetReadOffset(beforeReadIndex + length)
+    }
+	return packet
+}
+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
+}
+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
+}
+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
+}