mirror of
https://github.com/tiennm99/zfoo.git
synced 2026-05-20 22:24:40 +00:00
test[rust]: rust protocol test
This commit is contained in:
godotg
@@ -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() {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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>;
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user