From de9cafc6ac4d2cd0bf5b9a8d09805a2453aef8ff Mon Sep 17 00:00:00 2001
From: godotg <jaysunxiao@gmail.com>
Date: Sun, 21 Jul 2024 21:49:48 +0800
Subject: [PATCH] test[rust]: rust protocol test

---
 protocol/src/test/rust/main.rs                |   2 +-
 .../src/test/rust/zfoorust/byte_buffer.rs     | 537 +++++++++++++++++-
 .../src/test/rust/zfoorust/i_byte_buffer.rs   |  48 ++
 .../src/test/rust/zfoorust/normalObject.rs    | 228 +++-----
 protocol/src/test/rust/zfoorust/objectA.rs    |  32 +-
 5 files changed, 657 insertions(+), 190 deletions(-)

diff --git a/protocol/src/test/rust/main.rs b/protocol/src/test/rust/main.rs
index 6b0ff16a..c4b09149 100644
--- a/protocol/src/test/rust/main.rs
+++ b/protocol/src/test/rust/main.rs
@@ -33,7 +33,7 @@ fn main() {
     println!("new_byte_buffer length:[{}]", new_byte_buffer.getWriteOffset());
     let new_message = read(&mut new_byte_buffer);
     let new_packet = new_message.downcast_ref::<NormalObject>().unwrap();
-    println!("hello {}", new_packet.g);
+    println!("new packet g:{}", new_packet.g);
 }
 
 fn byte_buffer_test() {
diff --git a/protocol/src/test/rust/zfoorust/byte_buffer.rs b/protocol/src/test/rust/zfoorust/byte_buffer.rs
index 48d6eb1e..2c879946 100644
--- a/protocol/src/test/rust/zfoorust/byte_buffer.rs
+++ b/protocol/src/test/rust/zfoorust/byte_buffer.rs
@@ -3,6 +3,8 @@
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
 use std::any::Any;
+use std::collections::HashMap;
+use std::collections::HashSet;
 use crate::zfoorust::i_byte_buffer::IByteBuffer;
 use crate::zfoorust::protocol_manager::writeNoProtocolId;
 use crate::zfoorust::protocol_manager::readNoProtocolId;
@@ -51,7 +53,7 @@ impl IByteBuffer for ByteBuffer {
         }
     }
 
-    fn compatibleRead(&mut self, beforeReadIndex: i32, length: i32) -> bool{
+    fn compatibleRead(&mut self, beforeReadIndex: i32, length: i32) -> bool {
         return length != -1 && self.getReadOffset() < length + beforeReadIndex;
     }
 
@@ -449,4 +451,537 @@ impl IByteBuffer for ByteBuffer {
     fn readPacket(&mut self, protocolId: i16) -> Box<dyn Any> {
         return readNoProtocolId(self, protocolId);
     }
+
+    fn writeBoolArray(&mut self, array: &Vec<bool>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeBool(*ele);
+            }
+        }
+    }
+
+    fn readBoolArray(&mut self) -> Vec<bool> {
+        let mut array: Vec<bool> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readBool());
+            }
+        }
+        return array;
+    }
+
+    fn writeByteArray(&mut self, array: &Vec<i8>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeByte(*ele);
+            }
+        }
+    }
+
+    fn readByteArray(&mut self) -> Vec<i8> {
+        let mut array: Vec<i8> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readByte());
+            }
+        }
+        return array;
+    }
+
+    fn writeShortArray(&mut self, array: &Vec<i16>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeShort(*ele);
+            }
+        }
+    }
+
+    fn readShortArray(&mut self) -> Vec<i16> {
+        let mut array: Vec<i16> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readShort());
+            }
+        }
+        return array;
+    }
+
+    fn writeIntArray(&mut self, array: &Vec<i32>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeInt(*ele);
+            }
+        }
+    }
+
+    fn readIntArray(&mut self) -> Vec<i32> {
+        let mut array: Vec<i32> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readInt());
+            }
+        }
+        return array;
+    }
+
+    fn writeLongArray(&mut self, array: &Vec<i64>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeLong(*ele);
+            }
+        }
+    }
+
+    fn readLongArray(&mut self) -> Vec<i64> {
+        let mut array: Vec<i64> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readLong());
+            }
+        }
+        return array;
+    }
+
+    fn writeFloatArray(&mut self, array: &Vec<f32>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeFloat(*ele);
+            }
+        }
+    }
+
+    fn readFloatArray(&mut self) -> Vec<f32> {
+        let mut array: Vec<f32> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readFloat());
+            }
+        }
+        return array;
+    }
+
+    fn writeDoubleArray(&mut self, array: &Vec<f64>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeDouble(*ele);
+            }
+        }
+    }
+
+    fn readDoubleArray(&mut self) -> Vec<f64> {
+        let mut array: Vec<f64> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readDouble());
+            }
+        }
+        return array;
+    }
+
+    fn writeStringArray(&mut self, array: &Vec<String>) {
+        if array.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(array.len() as i32);
+            for ele in array {
+                self.writeString(String::from(ele));
+            }
+        }
+    }
+
+    fn readStringArray(&mut self) -> Vec<String> {
+        let mut array: Vec<String> = Vec::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                array.push(self.readString());
+            }
+        }
+        return array;
+    }
+
+    fn writeBoolSet(&mut self, set: &HashSet<bool>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeBool(*ele);
+            }
+        }
+    }
+
+    fn readBoolSet(&mut self) -> HashSet<bool> {
+        let mut set: HashSet<bool> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readBool());
+            }
+        }
+        return set;
+    }
+
+    fn writeByteSet(&mut self, set: &HashSet<i8>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeByte(*ele);
+            }
+        }
+    }
+
+    fn readByteSet(&mut self) -> HashSet<i8> {
+        let mut set: HashSet<i8> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readByte());
+            }
+        }
+        return set;
+    }
+
+    fn writeShortSet(&mut self, set: &HashSet<i16>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeShort(*ele);
+            }
+        }
+    }
+
+    fn readShortSet(&mut self) -> HashSet<i16> {
+        let mut set: HashSet<i16> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readShort());
+            }
+        }
+        return set;
+    }
+
+    fn writeIntSet(&mut self, set: &HashSet<i32>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeInt(*ele);
+            }
+        }
+    }
+
+    fn readIntSet(&mut self) -> HashSet<i32> {
+        let mut set: HashSet<i32> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readInt());
+            }
+        }
+        return set;
+    }
+
+    fn writeLongSet(&mut self, set: &HashSet<i64>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeLong(*ele);
+            }
+        }
+    }
+
+    fn readLongSet(&mut self) -> HashSet<i64> {
+        let mut set: HashSet<i64> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readLong());
+            }
+        }
+        return set;
+    }
+
+    fn writeStringSet(&mut self, set: &HashSet<String>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeString(String::from(ele));
+            }
+        }
+    }
+
+    fn readStringSet(&mut self) -> HashSet<String> {
+        let mut set: HashSet<String> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readString());
+            }
+        }
+        return set;
+    }
+
+    fn writeIntIntMap(&mut self, map: &HashMap<i32, i32>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeInt(key);
+                self.writeInt(value)
+            }
+        }
+    }
+
+    fn readIntIntMap(&mut self) -> HashMap<i32, i32> {
+        let mut map: HashMap<i32, i32> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readInt();
+                let value = self.readInt();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeIntLongMap(&mut self, map: &HashMap<i32, i64>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeInt(key);
+                self.writeLong(value)
+            }
+        }
+    }
+
+    fn readIntLongMap(&mut self) -> HashMap<i32, i64> {
+        let mut map: HashMap<i32, i64> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readInt();
+                let value = self.readLong();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeIntStringMap(&mut self, map: &HashMap<i32, String>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeInt(key);
+                self.writeString(value)
+            }
+        }
+    }
+
+    fn readIntStringMap(&mut self) -> HashMap<i32, String> {
+        let mut map: HashMap<i32, String> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readInt();
+                let value = self.readString();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeLongIntMap(&mut self, map: &HashMap<i64, i32>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeLong(key);
+                self.writeInt(value)
+            }
+        }
+    }
+
+    fn readLongIntMap(&mut self) -> HashMap<i64, i32> {
+        let mut map: HashMap<i64, i32> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readLong();
+                let value = self.readInt();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeLongLongMap(&mut self, map: &HashMap<i64, i64>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeLong(key);
+                self.writeLong(value)
+            }
+        }
+    }
+
+    fn readLongLongMap(&mut self) -> HashMap<i64, i64> {
+        let mut map: HashMap<i64, i64> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readLong();
+                let value = self.readLong();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeLongStringMap(&mut self, map: &HashMap<i64, String>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeLong(key);
+                self.writeString(value)
+            }
+        }
+    }
+
+    fn readLongStringMap(&mut self) -> HashMap<i64, String> {
+        let mut map: HashMap<i64, String> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readLong();
+                let value = self.readString();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeStringIntMap(&mut self, map: &HashMap<String, i32>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeString(key);
+                self.writeInt(value)
+            }
+        }
+    }
+
+    fn readStringIntMap(&mut self) -> HashMap<String, i32> {
+        let mut map: HashMap<String, i32> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readString();
+                let value = self.readInt();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeStringLongMap(&mut self, map: &HashMap<String, i64>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeString(key);
+                self.writeLong(value)
+            }
+        }
+    }
+
+    fn readStringLongMap(&mut self) -> HashMap<String, i64> {
+        let mut map: HashMap<String, i64> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readString();
+                let value = self.readLong();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
+
+    fn writeStringStringMap(&mut self, map: &HashMap<String, String>) {
+        if map.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(map.len() as i32);
+            for (key, value) in map.clone() {
+                self.writeString(key);
+                self.writeString(value)
+            }
+        }
+    }
+
+    fn readStringStringMap(&mut self) -> HashMap<String, String> {
+        let mut map: HashMap<String, String> = HashMap::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                let key = self.readString();
+                let value = self.readString();
+                map.insert(key, value);
+            }
+        }
+        return map;
+    }
 }
\ No newline at end of file
diff --git a/protocol/src/test/rust/zfoorust/i_byte_buffer.rs b/protocol/src/test/rust/zfoorust/i_byte_buffer.rs
index 179a0b51..b87eb8f1 100644
--- a/protocol/src/test/rust/zfoorust/i_byte_buffer.rs
+++ b/protocol/src/test/rust/zfoorust/i_byte_buffer.rs
@@ -2,6 +2,8 @@
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
+use std::collections::HashMap;
+use std::collections::HashSet;
 use std::any::Any;
 
 pub trait IPacket {
@@ -52,4 +54,50 @@ pub trait IByteBuffer {
     fn readString(&mut self) -> String;
     fn writePacket(&mut self, packet: &dyn Any, protocolId: i16);
     fn readPacket(&mut self, protocolId: i16) -> Box<dyn Any>;
+    fn writeBoolArray(&mut self, array: &Vec<bool>);
+    fn readBoolArray(&mut self) -> Vec<bool>;
+    fn writeByteArray(&mut self, array: &Vec<i8>);
+    fn readByteArray(&mut self) -> Vec<i8>;
+    fn writeShortArray(&mut self, array: &Vec<i16>);
+    fn readShortArray(&mut self) -> Vec<i16>;
+    fn writeIntArray(&mut self, array: &Vec<i32>);
+    fn readIntArray(&mut self) -> Vec<i32>;
+    fn writeLongArray(&mut self, array: &Vec<i64>);
+    fn readLongArray(&mut self) -> Vec<i64>;
+    fn writeFloatArray(&mut self, array: &Vec<f32>);
+    fn readFloatArray(&mut self) -> Vec<f32>;
+    fn writeDoubleArray(&mut self, array: &Vec<f64>);
+    fn readDoubleArray(&mut self) -> Vec<f64>;
+    fn writeStringArray(&mut self, array: &Vec<String>);
+    fn readStringArray(&mut self) -> Vec<String>;
+    fn writeBoolSet(&mut self, set: &HashSet<bool>);
+    fn readBoolSet(&mut self) -> HashSet<bool>;
+    fn writeByteSet(&mut self, set: &HashSet<i8>);
+    fn readByteSet(&mut self) -> HashSet<i8>;
+    fn writeShortSet(&mut self, set: &HashSet<i16>);
+    fn readShortSet(&mut self) -> HashSet<i16>;
+    fn writeIntSet(&mut self, set: &HashSet<i32>);
+    fn readIntSet(&mut self) -> HashSet<i32>;
+    fn writeLongSet(&mut self, set: &HashSet<i64>);
+    fn readLongSet(&mut self) -> HashSet<i64>;
+    fn writeStringSet(&mut self, set: &HashSet<String>);
+    fn readStringSet(&mut self) -> HashSet<String>;
+    fn writeIntIntMap(&mut self, map: &HashMap<i32, i32>);
+    fn readIntIntMap(&mut self) -> HashMap<i32, i32>;
+    fn writeIntLongMap(&mut self, map: &HashMap<i32, i64>);
+    fn readIntLongMap(&mut self) -> HashMap<i32, i64>;
+    fn writeIntStringMap(&mut self, map: &HashMap<i32, String>);
+    fn readIntStringMap(&mut self) -> HashMap<i32, String>;
+    fn writeLongIntMap(&mut self, map: &HashMap<i64, i32>);
+    fn readLongIntMap(&mut self) -> HashMap<i64, i32>;
+    fn writeLongLongMap(&mut self, map: &HashMap<i64, i64>);
+    fn readLongLongMap(&mut self) -> HashMap<i64, i64>;
+    fn writeLongStringMap(&mut self, map: &HashMap<i64, String>);
+    fn readLongStringMap(&mut self) -> HashMap<i64, String>;
+    fn writeStringIntMap(&mut self, map: &HashMap<String, i32>);
+    fn readStringIntMap(&mut self) -> HashMap<String, i32>;
+    fn writeStringLongMap(&mut self, map: &HashMap<String, i64>);
+    fn readStringLongMap(&mut self) -> HashMap<String, i64>;
+    fn writeStringStringMap(&mut self, map: &HashMap<String, String>);
+    fn readStringStringMap(&mut self) -> HashMap<String, String>;
 }
\ No newline at end of file
diff --git a/protocol/src/test/rust/zfoorust/normalObject.rs b/protocol/src/test/rust/zfoorust/normalObject.rs
index 5a404708..c1ad0b13 100644
--- a/protocol/src/test/rust/zfoorust/normalObject.rs
+++ b/protocol/src/test/rust/zfoorust/normalObject.rs
@@ -75,14 +75,7 @@ pub fn writeNormalObject(buffer: &mut dyn IByteBuffer, packet: &dyn Any) {
     let beforeWriteIndex = buffer.getWriteOffset();
     buffer.writeInt(857);
     buffer.writeByte(message.a);
-    if message.aaa.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.aaa.len() as i32);
-        for element0 in message.aaa.clone() {
-            buffer.writeByte(element0);
-        }
-    }
+    buffer.writeByteArray(&message.aaa);
     buffer.writeShort(message.b);
     buffer.writeInt(message.c);
     buffer.writeLong(message.d);
@@ -91,72 +84,29 @@ pub fn writeNormalObject(buffer: &mut dyn IByteBuffer, packet: &dyn Any) {
     buffer.writeBool(message.g);
     buffer.writeString(message.jj.clone());
     buffer.writePacket(&message.kk, 102);
-    if message.l.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.l.len() as i32);
-        for element1 in message.l.clone() {
-            buffer.writeInt(element1);
-        }
-    }
-    if message.ll.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.ll.len() as i32);
-        for element2 in message.ll.clone() {
-            buffer.writeLong(element2);
-        }
-    }
+    buffer.writeIntArray(&message.l);
+    buffer.writeLongArray(&message.ll);
     if message.lll.is_empty() {
         buffer.writeInt(0);
     } else {
         buffer.writeInt(message.lll.len() as i32);
-        for element3 in message.lll.clone() {
-            buffer.writePacket(&element3, 102);
-        }
-    }
-    if message.llll.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.llll.len() as i32);
-        for element4 in message.llll.clone() {
-            buffer.writeString(element4.clone());
-        }
-    }
-    if message.m.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.m.len() as i32);
-        for (key5, value6) in message.m.clone() {
-            buffer.writeInt(key5);
-            buffer.writeString(value6.clone());
+        for element0 in message.lll.clone() {
+            buffer.writePacket(&element0, 102);
         }
     }
+    buffer.writeStringArray(&message.llll);
+    buffer.writeIntStringMap(&message.m);
     if message.mm.is_empty() {
         buffer.writeInt(0);
     } else {
         buffer.writeInt(message.mm.len() as i32);
-        for (key7, value8) in message.mm.clone() {
-            buffer.writeInt(key7);
-            buffer.writePacket(&value8, 102);
-        }
-    }
-    if message.s.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.s.len() as i32);
-        for element9 in message.s.clone() {
-            buffer.writeInt(element9);
-        }
-    }
-    if message.ssss.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.ssss.len() as i32);
-        for element10 in message.ssss.clone() {
-            buffer.writeString(element10.clone());
+        for (key1, value2) in message.mm.clone() {
+            buffer.writeInt(key1);
+            buffer.writePacket(&value2, 102);
         }
     }
+    buffer.writeIntSet(&message.s);
+    buffer.writeStringSet(&message.ssss);
     buffer.writeInt(message.outCompatibleValue);
     buffer.writeInt(message.outCompatibleValue2);
     buffer.adjustPadding(857, beforeWriteIndex);
@@ -171,115 +121,65 @@ pub fn readNormalObject(buffer: &mut dyn IByteBuffer) -> Box<dyn Any> {
     let beforeReadIndex = buffer.getReadOffset();
     let result0 = buffer.readByte();
     packet.a = result0;
-    let mut result1: Vec<i8> = Vec::new();
-    let size3 = buffer.readInt();
-    if size3 > 0 {
-        for index2 in 0 .. size3 {
-            let result4 = buffer.readByte();
-            result1.push(result4);
+    let array1 = buffer.readByteArray();
+    packet.aaa = array1;
+    let result2 = buffer.readShort();
+    packet.b = result2;
+    let result3 = buffer.readInt();
+    packet.c = result3;
+    let result4 = buffer.readLong();
+    packet.d = result4;
+    let result5 = buffer.readFloat();
+    packet.e = result5;
+    let result6 = buffer.readDouble();
+    packet.f = result6;
+    let result7 = buffer.readBool(); 
+    packet.g = result7;
+    let result8 = buffer.readString();
+    packet.jj = result8;
+    let result9 = buffer.readPacket(102);
+    let result10 = result9.downcast_ref::<ObjectA>().unwrap().clone();
+    packet.kk = result10;
+    let list11 = buffer.readIntArray();
+    packet.l = list11;
+    let list12 = buffer.readLongArray();
+    packet.ll = list12;
+    let mut result13: Vec<ObjectA> = Vec::new();
+    let size14 = buffer.readInt();
+    if size14 > 0 {
+        for index15 in 0..size14 {
+            let result16 = buffer.readPacket(102);
+            let result17 = result16.downcast_ref::<ObjectA>().unwrap().clone();
+            result13.push(result17);
         }
     }
-    packet.aaa = result1;
-    let result5 = buffer.readShort();
-    packet.b = result5;
-    let result6 = buffer.readInt();
-    packet.c = result6;
-    let result7 = buffer.readLong();
-    packet.d = result7;
-    let result8 = buffer.readFloat();
-    packet.e = result8;
-    let result9 = buffer.readDouble();
-    packet.f = result9;
-    let result10 = buffer.readBool(); 
-    packet.g = result10;
-    let result11 = buffer.readString();
-    packet.jj = result11;
-    let result12 = buffer.readPacket(102);
-    let result13 = result12.downcast_ref::<ObjectA>().unwrap().clone();
-    packet.kk = result13;
-    let mut result14: Vec<i32> = Vec::new();
-    let size15 = buffer.readInt();
-    if size15 > 0 {
-        for index16 in 0 .. size15 {
-            let result17 = buffer.readInt();
-            result14.push(result17);
+    packet.lll = result13;
+    let list18 = buffer.readStringArray();
+    packet.llll = list18;
+    let map19 = buffer.readIntStringMap();
+    packet.m = map19;
+    let mut result20: HashMap<i32, ObjectA> = HashMap::new();
+    let size21 = buffer.readInt();
+    if size21 > 0 {
+        for index22 in 0..size21 {
+            let result23 = buffer.readInt();
+            let result24 = buffer.readPacket(102);
+            let result25 = result24.downcast_ref::<ObjectA>().unwrap().clone();
+            result20.insert(result23, result25);
         }
     }
-    packet.l = result14;
-    let mut result18: Vec<i64> = Vec::new();
-    let size19 = buffer.readInt();
-    if size19 > 0 {
-        for index20 in 0 .. size19 {
-            let result21 = buffer.readLong();
-            result18.push(result21);
-        }
-    }
-    packet.ll = result18;
-    let mut result22: Vec<ObjectA> = Vec::new();
-    let size23 = buffer.readInt();
-    if size23 > 0 {
-        for index24 in 0 .. size23 {
-            let result25 = buffer.readPacket(102);
-            let result26 = result25.downcast_ref::<ObjectA>().unwrap().clone();
-            result22.push(result26);
-        }
-    }
-    packet.lll = result22;
-    let mut result27: Vec<String> = Vec::new();
-    let size28 = buffer.readInt();
-    if size28 > 0 {
-        for index29 in 0 .. size28 {
-            let result30 = buffer.readString();
-            result27.push(result30);
-        }
-    }
-    packet.llll = result27;
-    let mut result31: HashMap<i32, String> = HashMap::new();
-    let size32 = buffer.readInt();
-    if size32 > 0 {
-        for index33 in 0 .. size32 {
-            let result34 = buffer.readInt();
-            let result35 = buffer.readString();
-            result31.insert(result34, result35);
-        }
-    }
-    packet.m = result31;
-    let mut result36: HashMap<i32, ObjectA> = HashMap::new();
-    let size37 = buffer.readInt();
-    if size37 > 0 {
-        for index38 in 0 .. size37 {
-            let result39 = buffer.readInt();
-            let result40 = buffer.readPacket(102);
-            let result41 = result40.downcast_ref::<ObjectA>().unwrap().clone();
-            result36.insert(result39, result41);
-        }
-    }
-    packet.mm = result36;
-    let mut result42: HashSet<i32> = HashSet::new();
-    let size43 = buffer.readInt();
-    if size43 > 0 {
-        for index44 in 0 .. size43 {
-            let result45 = buffer.readInt();
-            result42.insert(result45);
-        }
-    }
-    packet.s = result42;
-    let mut result46: HashSet<String> = HashSet::new();
-    let size47 = buffer.readInt();
-    if size47 > 0 {
-        for index48 in 0 .. size47 {
-            let result49 = buffer.readString();
-            result46.insert(result49);
-        }
-    }
-    packet.ssss = result46;
+    packet.mm = result20;
+    let set26 = buffer.readIntSet();
+    packet.s = set26;
+    let set27 = buffer.readStringSet();
+    packet.ssss = set27;
     if buffer.compatibleRead(beforeReadIndex, length) {
-        let result50 = buffer.readInt();
-        packet.outCompatibleValue = result50;
+        let result28 = buffer.readInt();
+        packet.outCompatibleValue = result28;
     }
     if buffer.compatibleRead(beforeReadIndex, length) {
-        let result51 = buffer.readInt();
-        packet.outCompatibleValue2 = result51;
+        let result29 = buffer.readInt();
+        packet.outCompatibleValue2 = result29;
     }
     if length > 0 {
         buffer.setReadOffset(beforeReadIndex + length);
diff --git a/protocol/src/test/rust/zfoorust/objectA.rs b/protocol/src/test/rust/zfoorust/objectA.rs
index 5c7facaf..2876a22b 100644
--- a/protocol/src/test/rust/zfoorust/objectA.rs
+++ b/protocol/src/test/rust/zfoorust/objectA.rs
@@ -41,15 +41,7 @@ pub fn writeObjectA(buffer: &mut dyn IByteBuffer, packet: &dyn Any) {
     let beforeWriteIndex = buffer.getWriteOffset();
     buffer.writeInt(201);
     buffer.writeInt(message.a);
-    if message.m.is_empty() {
-        buffer.writeInt(0);
-    } else {
-        buffer.writeInt(message.m.len() as i32);
-        for (key0, value1) in message.m.clone() {
-            buffer.writeInt(key0);
-            buffer.writeString(value1.clone());
-        }
-    }
+    buffer.writeIntStringMap(&message.m);
     buffer.writePacket(&message.objectB, 103);
     buffer.writeInt(message.innerCompatibleValue);
     buffer.adjustPadding(201, beforeWriteIndex);
@@ -64,22 +56,14 @@ pub fn readObjectA(buffer: &mut dyn IByteBuffer) -> Box<dyn Any> {
     let beforeReadIndex = buffer.getReadOffset();
     let result0 = buffer.readInt();
     packet.a = result0;
-    let mut result1: HashMap<i32, String> = HashMap::new();
-    let size2 = buffer.readInt();
-    if size2 > 0 {
-        for index3 in 0 .. size2 {
-            let result4 = buffer.readInt();
-            let result5 = buffer.readString();
-            result1.insert(result4, result5);
-        }
-    }
-    packet.m = result1;
-    let result6 = buffer.readPacket(103);
-    let result7 = result6.downcast_ref::<ObjectB>().unwrap().clone();
-    packet.objectB = result7;
+    let map1 = buffer.readIntStringMap();
+    packet.m = map1;
+    let result2 = buffer.readPacket(103);
+    let result3 = result2.downcast_ref::<ObjectB>().unwrap().clone();
+    packet.objectB = result3;
     if buffer.compatibleRead(beforeReadIndex, length) {
-        let result8 = buffer.readInt();
-        packet.innerCompatibleValue = result8;
+        let result4 = buffer.readInt();
+        packet.innerCompatibleValue = result4;
     }
     if length > 0 {
         buffer.setReadOffset(beforeReadIndex + length);