From 293ccb4e2175219b1fc73a7f57aed1060c85607c Mon Sep 17 00:00:00 2001 From: godotg Date: Sun, 21 Jul 2024 16:09:55 +0800 Subject: [PATCH] test[rust]: protocol test --- protocol/src/test/rust/main.rs | 82 ++++ .../src/test/rust/zfoorust/byte_buffer.rs | 452 ++++++++++++++++++ .../src/test/rust/zfoorust/emptyObject.rs | 50 ++ .../src/test/rust/zfoorust/i_byte_buffer.rs | 55 +++ protocol/src/test/rust/zfoorust/mod.rs | 8 + .../src/test/rust/zfoorust/normalObject.rs | 288 +++++++++++ protocol/src/test/rust/zfoorust/objectA.rs | 88 ++++ protocol/src/test/rust/zfoorust/objectB.rs | 61 +++ .../test/rust/zfoorust/protocol_manager.rs | 45 ++ .../src/test/rust/zfoorust/simpleObject.rs | 57 +++ 10 files changed, 1186 insertions(+) create mode 100644 protocol/src/test/rust/main.rs create mode 100644 protocol/src/test/rust/zfoorust/byte_buffer.rs create mode 100644 protocol/src/test/rust/zfoorust/emptyObject.rs create mode 100644 protocol/src/test/rust/zfoorust/i_byte_buffer.rs create mode 100644 protocol/src/test/rust/zfoorust/mod.rs create mode 100644 protocol/src/test/rust/zfoorust/normalObject.rs create mode 100644 protocol/src/test/rust/zfoorust/objectA.rs create mode 100644 protocol/src/test/rust/zfoorust/objectB.rs create mode 100644 protocol/src/test/rust/zfoorust/protocol_manager.rs create mode 100644 protocol/src/test/rust/zfoorust/simpleObject.rs diff --git a/protocol/src/test/rust/main.rs b/protocol/src/test/rust/main.rs new file mode 100644 index 00000000..6b0ff16a --- /dev/null +++ b/protocol/src/test/rust/main.rs @@ -0,0 +1,82 @@ +mod zfoorust; + +use std::fs::File; +use std::io::Read; +use std::path::Path; +use crate::zfoorust::byte_buffer::{ByteBuffer}; +use crate::zfoorust::i_byte_buffer::{IByteBuffer, IPacket}; +use crate::zfoorust::protocol_manager::{write, read}; +use crate::zfoorust::normalObject::NormalObject; +fn main() { + byte_buffer_test(); + + // let path = Path::new("C:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-no-compatible.bytes"); + // let path = Path::new("C:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-compatible.bytes"); + // let path = Path::new("C:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-inner-compatible.bytes"); + // let path = Path::new("C:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-inner-compatible.bytes"); + let path = Path::new("C:\\github\\zfoo\\protocol\\src\\test\\resources\\compatible\\normal-out-inner-inner-compatible.bytes"); + let mut file = File::open(path).expect("Failed to open file"); + let mut content = Vec::new(); + file.read_to_end(&mut content).expect("Failed to read file"); + println!("File content: {:?}", content.len()); + + let mut byte_buffer = ByteBuffer::new(); + byte_buffer.writeUBytes(&content); + println!("buffer length:[{}]", byte_buffer.getWriteOffset()); + + let message = read(&mut byte_buffer); + let packet = message.downcast_ref::().unwrap(); + + // read + let mut new_byte_buffer = ByteBuffer::new(); + write(&mut new_byte_buffer, packet, packet.protocolId()); + println!("new_byte_buffer length:[{}]", new_byte_buffer.getWriteOffset()); + let new_message = read(&mut new_byte_buffer); + let new_packet = new_message.downcast_ref::().unwrap(); + println!("hello {}", new_packet.g); +} + +fn byte_buffer_test() { + let mut buffer = ByteBuffer::new(); + buffer.ensureCapacity(200); + assert_eq!(buffer.getCapacity(), 128 * 2); + + buffer.writeBool(true); + assert_eq!(buffer.readBool(), true); + buffer.writeBool(false); + assert_eq!(buffer.readBool(), false); + + let bytes: [i8; 6] = [1, 2, 3, 4, 5, 6]; + buffer.writeBytes(&bytes); + let toBytes = buffer.toBytes(); + let expectBytes: [i8; 8] = [1, 0, 1, 2, 3, 4, 5, 6]; + assert_eq!(toBytes, expectBytes); + let bytes1 = buffer.readBytes(6); + + buffer.writeShort(9999); + assert_eq!(buffer.readShort(), 9999); + buffer.writeShort(-9999); + assert_eq!(buffer.readShort(), -9999); + + buffer.writeInt(-2147483648); + assert_eq!(buffer.readInt(), -2147483648); + buffer.writeInt(2147483647); + assert_eq!(buffer.readInt(), 2147483647); + + buffer.writeLong(-9223372036854775808); + assert_eq!(buffer.readLong(), -9223372036854775808); + buffer.writeLong(9223372036854775807); + assert_eq!(buffer.readLong(), 9223372036854775807); + + buffer.writeFloat(3.1415926); + assert_eq!(buffer.readFloat(), 3.1415926); + buffer.writeFloat(-3.1415926); + assert_eq!(buffer.readFloat(), -3.1415926); + buffer.writeDouble(3.1415926); + assert_eq!(buffer.readDouble(), 3.1415926); + buffer.writeDouble(-3.1415926); + assert_eq!(buffer.readDouble(), -3.1415926); + + buffer.writeString(String::from("hello")); + assert_eq!(buffer.readString(), String::from("hello")); +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/byte_buffer.rs b/protocol/src/test/rust/zfoorust/byte_buffer.rs new file mode 100644 index 00000000..48d6eb1e --- /dev/null +++ b/protocol/src/test/rust/zfoorust/byte_buffer.rs @@ -0,0 +1,452 @@ +#![allow(unused_imports)] +#![allow(dead_code)] +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] +use std::any::Any; +use crate::zfoorust::i_byte_buffer::IByteBuffer; +use crate::zfoorust::protocol_manager::writeNoProtocolId; +use crate::zfoorust::protocol_manager::readNoProtocolId; + +#[allow(non_snake_case)] +pub struct ByteBuffer { + buffer: Vec, + writeOffset: i32, + readOffset: i32, +} + +#[allow(non_snake_case)] +#[allow(dead_code)] +#[allow(unused_parens)] +impl ByteBuffer { + pub fn new() -> ByteBuffer { + let mut buffer = ByteBuffer { + buffer: Vec::new(), + writeOffset: 0, + readOffset: 0, + }; + buffer.buffer.resize(128, 0); + return buffer; + } +} +#[allow(non_snake_case)] +#[allow(dead_code)] +#[allow(unused_parens)] +impl IByteBuffer for ByteBuffer { + fn adjustPadding(&mut self, predictionLength: i32, beforeWriteIndex: i32) { + let currentWriteIndex = self.getWriteOffset(); + let predictionCount = self.writeIntCount(predictionLength); + let length = currentWriteIndex - beforeWriteIndex - predictionCount; + let lengthCount = self.writeIntCount(length); + let padding = lengthCount - predictionCount; + if (padding == 0) { + self.setWriteOffset(beforeWriteIndex); + self.writeInt(length); + self.setWriteOffset(currentWriteIndex); + } else { + let mut bytes: Vec = Vec::with_capacity(length as usize); + bytes.extend(&self.buffer[(currentWriteIndex - length) as usize..currentWriteIndex as usize]); + self.setWriteOffset(beforeWriteIndex); + self.writeInt(length); + self.writeBytes(bytes.as_slice()); + } + } + + fn compatibleRead(&mut self, beforeReadIndex: i32, length: i32) -> bool{ + return length != -1 && self.getReadOffset() < length + beforeReadIndex; + } + + fn getBuffer(&self) -> &Vec { + return &self.buffer; + } + + fn getWriteOffset(&self) -> i32 { + return self.writeOffset; + } + + fn setWriteOffset(&mut self, writeIndex: i32) { + self.writeOffset = writeIndex; + } + + fn getReadOffset(&self) -> i32 { + return self.readOffset; + } + + fn setReadOffset(&mut self, readIndex: i32) { + self.readOffset = readIndex; + } + + fn getCapacity(&self) -> i32 { + return self.buffer.capacity() as i32 - self.writeOffset; + } + + fn ensureCapacity(&mut self, capacity: i32) { + while capacity > self.getCapacity() { + self.buffer.resize(self.buffer.capacity() * 2, 0); + } + } + + fn isReadable(&self) -> bool { + return self.writeOffset > self.readOffset; + } + + fn writeBytes(&mut self, bytes: &[i8]) { + let length = bytes.len() as i32; + self.ensureCapacity(length); + for byte in bytes { + self.writeByte(*byte); + } + } + + fn readBytes(&mut self, count: i32) -> &[i8] { + let value = &self.buffer[self.readOffset as usize..(self.readOffset + count) as usize]; + self.readOffset += count; + return value; + } + + fn writeUBytes(&mut self, bytes: &[u8]) { + let length = bytes.len() as i32; + self.ensureCapacity(length); + for byte in bytes { + self.writeUByte(*byte); + } + } + + fn readUBytes(&mut self, count: i32) -> Vec { + let mut bytes: Vec = Vec::new(); + bytes.resize(count as usize, 0); + for i in 0..count { + bytes[i as usize] = self.readUByte(); + } + return bytes; + } + + fn toBytes(&self) -> &[i8] { + return &self.buffer[0..self.writeOffset as usize]; + } + + fn writeBool(&mut self, value: bool) { + self.ensureCapacity(1); + self.buffer[self.writeOffset as usize] = if value { 1 } else { 0 }; + self.writeOffset += 1; + } + + fn readBool(&mut self) -> bool { + let value = self.buffer[self.readOffset as usize]; + self.readOffset += 1; + return value != 0; + } + + fn writeByte(&mut self, value: i8) { + self.ensureCapacity(1); + self.buffer[self.writeOffset as usize] = value; + self.writeOffset += 1; + } + + fn readByte(&mut self) -> i8 { + let value = self.buffer[self.readOffset as usize]; + self.readOffset += 1; + return value; + } + + fn writeUByte(&mut self, value: u8) { + self.ensureCapacity(1); + self.buffer[self.writeOffset as usize] = value as i8; + self.writeOffset += 1; + } + + fn readUByte(&mut self) -> u8 { + let value = self.buffer[self.readOffset as usize]; + self.readOffset += 1; + return value as u8; + } + + fn writeShort(&mut self, value: i16) { + self.ensureCapacity(2); + self.buffer[self.writeOffset as usize] = (value >> 8) as i8; + self.buffer[self.writeOffset as usize + 1] = value as i8; + self.writeOffset += 2; + } + + fn readShort(&mut self) -> i16 { + let value = (self.buffer[self.readOffset as usize] as i16) << 8 + | (self.buffer[self.readOffset as usize + 1] as u8) as i16; + self.readOffset += 2; + return value; + } + + fn writeRawInt(&mut self, value: i32) { + self.writeByte((value >> 24) as i8); + self.writeByte((value >> 16) as i8); + self.writeByte((value >> 8) as i8); + self.writeByte(value as i8); + } + + fn readRawInt(&mut self) -> i32 { + let value = (self.readUByte() as i32) << 24 + | (self.readUByte() as i32) << 16 + | (self.readUByte() as i32) << 8 + | (self.readUByte() as i32); + return value; + } + + fn writeInt(&mut self, intValue: i32) { + let value = ((intValue << 1) ^ (intValue >> 31)) as u32; + + if (value >> 7 == 0) { + self.writeByte(value as i8); + return; + } + + if (value >> 14 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte((value >> 7) as i8); + return; + } + + if (value >> 21 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte((value >> 14) as i8); + return; + } + + if (value >> 28 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte((value >> 21) as i8); + return; + } + + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte((value >> 28) as i8); + } + + fn writeIntCount(&mut self, intValue: i32) -> i32 { + let value = ((intValue << 1) ^ (intValue >> 31)) as u32; + 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; + } + + fn readInt(&mut self) -> i32 { + let mut b = self.readUByte() as u32; + let mut value = b & 0x7F; + if ((b & 0x80) != 0) { + b = self.readUByte() as u32; + value |= (b & 0x7F) << 7; + if ((b & 0x80) != 0) { + b = self.readUByte() as u32; + value |= (b & 0x7F) << 14; + if ((b & 0x80) != 0) { + b = self.readUByte() as u32; + value |= (b & 0x7F) << 21; + if ((b & 0x80) != 0) { + b = self.readUByte() as u32; + value |= (b & 0x7F) << 28; + } + } + } + } + return (value >> 1) as i32 ^ -((value as i32) & 1); + } + + fn writeRawLong(&mut self, value: i64) { + self.writeByte((value >> 56) as i8); + self.writeByte((value >> 48) as i8); + self.writeByte((value >> 40) as i8); + self.writeByte((value >> 32) as i8); + self.writeByte((value >> 24) as i8); + self.writeByte((value >> 16) as i8); + self.writeByte((value >> 8) as i8); + self.writeByte(value as i8); + } + + fn readRawLong(&mut self) -> i64 { + let value = (self.readUByte() as i64) << 56 + | (self.readUByte() as i64) << 48 + | (self.readUByte() as i64) << 40 + | (self.readUByte() as i64) << 32 + | (self.readUByte() as i64) << 24 + | (self.readUByte() as i64) << 16 + | (self.readUByte() as i64) << 8 + | (self.readUByte() as i64); + return value; + } + + fn writeLong(&mut self, longValue: i64) { + let value = ((longValue << 1) ^ (longValue >> 63)) as u64; + + if (value >> 7 == 0) { + self.writeByte(value as i8); + return; + } + + if (value >> 14 == 0) { + self.writeByte(((value & 0x7F) | 0x80) as i8); + self.writeByte((value >> 7) as i8); + return; + } + + if (value >> 21 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte((value >> 14) as i8); + return; + } + + if ((value >> 28) == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte((value >> 21) as i8); + return; + } + + if (value >> 35 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte((value >> 28) as i8); + return; + } + + if (value >> 42 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte(((value >> 28) | 0x80) as i8); + self.writeByte((value >> 35) as i8); + return; + } + + if (value >> 49 == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte(((value >> 28) | 0x80) as i8); + self.writeByte(((value >> 35) | 0x80) as i8); + self.writeByte((value >> 42) as i8); + return; + } + + if ((value >> 56) == 0) { + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte(((value >> 28) | 0x80) as i8); + self.writeByte(((value >> 35) | 0x80) as i8); + self.writeByte(((value >> 42) | 0x80) as i8); + self.writeByte((value >> 49) as i8); + return; + } + + self.writeByte((value | 0x80) as i8); + self.writeByte(((value >> 7) | 0x80) as i8); + self.writeByte(((value >> 14) | 0x80) as i8); + self.writeByte(((value >> 21) | 0x80) as i8); + self.writeByte(((value >> 28) | 0x80) as i8); + self.writeByte(((value >> 35) | 0x80) as i8); + self.writeByte(((value >> 42) | 0x80) as i8); + self.writeByte(((value >> 49) | 0x80) as i8); + self.writeByte((value >> 56) as i8); + } + + fn readLong(&mut self) -> i64 { + let mut b = self.readUByte() as u64; + let mut value = b & 0x7F; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 7; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 14; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 21; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 28; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 35; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 42; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= (b & 0x7F) << 49; + if ((b & 0x80) != 0) { + b = self.readUByte() as u64; + value |= b << 56; + } + } + } + } + } + } + } + } + + return (value >> 1) as i64 ^ -(value as i64 & 1); + } + + fn writeFloat(&mut self, value: f32) { + self.writeRawInt(value.to_bits() as i32); + } + + fn readFloat(&mut self) -> f32 { + return f32::from_bits(self.readRawInt() as u32); + } + + fn writeDouble(&mut self, value: f64) { + self.writeRawLong(value.to_bits() as i64); + } + + fn readDouble(&mut self) -> f64 { + return f64::from_bits(self.readRawLong() as u64); + } + + fn writeString(&mut self, value: String) { + if (value == "" || value.is_empty()) { + self.writeInt(0); + } + let bytes = value.as_bytes(); + self.writeInt(bytes.len() as i32); + self.writeUBytes(bytes); + } + + fn readString(&mut self) -> String { + let length = self.readInt(); + if (length <= 0) { + return String::from(""); + } + let bytes = self.readUBytes(length); + return String::from_utf8(bytes).unwrap(); + } + + fn writePacket(&mut self, packet: &dyn Any, protocolId: i16) { + writeNoProtocolId(self, packet, protocolId); + } + + fn readPacket(&mut self, protocolId: i16) -> Box { + return readNoProtocolId(self, protocolId); + } +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/emptyObject.rs b/protocol/src/test/rust/zfoorust/emptyObject.rs new file mode 100644 index 00000000..338d2964 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/emptyObject.rs @@ -0,0 +1,50 @@ +#![allow(dead_code)] +#![allow(unused_imports)] +#![allow(unused_mut)] +#![allow(unused_variables)] +#![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, IPacket}; + + +#[derive(Clone)] +pub struct EmptyObject { + +} + +impl IPacket for EmptyObject { + fn protocolId(&self) -> i16 { + return 0; + } +} + +impl EmptyObject { + pub fn new() -> EmptyObject { + let packet = EmptyObject { + + }; + return packet; + } +} + +pub fn writeEmptyObject(buffer: &mut dyn IByteBuffer, packet: &dyn Any) { + let message = packet.downcast_ref::().unwrap(); + buffer.writeInt(-1); +} + +pub fn readEmptyObject(buffer: &mut dyn IByteBuffer) -> Box { + let length = buffer.readInt(); + let mut packet = EmptyObject::new(); + if length == 0 { + return Box::new(packet); + } + let beforeReadIndex = buffer.getReadOffset(); + + if length > 0 { + buffer.setReadOffset(beforeReadIndex + length); + } + return Box::new(packet); +} \ 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 new file mode 100644 index 00000000..179a0b51 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/i_byte_buffer.rs @@ -0,0 +1,55 @@ +#![allow(unused_imports)] +#![allow(dead_code)] +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] +use std::any::Any; + +pub trait IPacket { + fn protocolId(&self) -> i16; +} + +#[allow(non_snake_case)] +#[allow(dead_code)] +#[allow(unused_parens)] +pub trait IByteBuffer { + fn adjustPadding(&mut self, predictionLength: i32, beforeWriteIndex: i32); + fn compatibleRead(&mut self, beforeReadIndex: i32, length: i32) -> bool; + fn getBuffer(&self) -> &Vec; + fn getWriteOffset(&self) -> i32; + fn setWriteOffset(&mut self, writeIndex: i32); + fn getReadOffset(&self) -> i32; + fn setReadOffset(&mut self, readIndex: i32); + fn getCapacity(&self) -> i32; + fn ensureCapacity(&mut self, capacity: i32); + fn isReadable(&self) -> bool; + fn writeBytes(&mut self, bytes: &[i8]); + fn readBytes(&mut self, count: i32) -> &[i8]; + fn writeUBytes(&mut self, bytes: &[u8]); + fn readUBytes(&mut self, count: i32) -> Vec; + fn toBytes(&self) -> &[i8]; + fn writeBool(&mut self, value: bool); + fn readBool(&mut self) -> bool; + fn writeByte(&mut self, value: i8); + fn readByte(&mut self) -> i8; + fn writeUByte(&mut self, value: u8); + fn readUByte(&mut self) -> u8; + fn writeShort(&mut self, value: i16); + fn readShort(&mut self) -> i16; + fn writeRawInt(&mut self, value: i32); + fn readRawInt(&mut self) -> i32; + fn writeInt(&mut self, intValue: i32); + fn writeIntCount(&mut self, intValue: i32) -> i32; + fn readInt(&mut self) -> i32; + fn writeRawLong(&mut self, value: i64); + fn readRawLong(&mut self) -> i64; + fn writeLong(&mut self, longValue: i64); + fn readLong(&mut self) -> i64; + fn writeFloat(&mut self, value: f32); + fn readFloat(&mut self) -> f32; + fn writeDouble(&mut self, value: f64); + fn readDouble(&mut self) -> f64; + fn writeString(&mut self, value: String); + fn readString(&mut self) -> String; + fn writePacket(&mut self, packet: &dyn Any, protocolId: i16); + fn readPacket(&mut self, protocolId: i16) -> Box; +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/mod.rs b/protocol/src/test/rust/zfoorust/mod.rs new file mode 100644 index 00000000..45a39807 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/mod.rs @@ -0,0 +1,8 @@ +pub mod i_byte_buffer; +pub mod byte_buffer; +pub mod protocol_manager; +pub mod emptyObject; +pub mod normalObject; +pub mod objectA; +pub mod objectB; +pub mod simpleObject; diff --git a/protocol/src/test/rust/zfoorust/normalObject.rs b/protocol/src/test/rust/zfoorust/normalObject.rs new file mode 100644 index 00000000..5a404708 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/normalObject.rs @@ -0,0 +1,288 @@ +#![allow(dead_code)] +#![allow(unused_imports)] +#![allow(unused_mut)] +#![allow(unused_variables)] +#![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, IPacket}; +use crate::zfoorust::objectA::ObjectA; +// 常规的对象，取所有语言语法的交集，基本上所有语言都支持下面的语法 +#[derive(Clone)] +pub struct NormalObject { + pub a: i8, + pub aaa: Vec, + pub b: i16, + // 整数类型 + pub c: i32, + pub d: i64, + pub e: f32, + pub f: f64, + pub g: bool, + pub jj: String, + pub kk: ObjectA, + pub l: Vec, + pub ll: Vec, + pub lll: Vec, + pub llll: Vec, + pub m: HashMap, + pub mm: HashMap, + pub s: HashSet, + pub ssss: HashSet, + pub outCompatibleValue: i32, + pub outCompatibleValue2: i32, +} + +impl IPacket for NormalObject { + fn protocolId(&self) -> i16 { + return 101; + } +} + +impl NormalObject { + pub fn new() -> NormalObject { + let packet = NormalObject { + a: 0, + aaa: Vec::new(), + b: 0, + // 整数类型 + c: 0, + d: 0, + e: 0f32, + f: 0f64, + g: false, + jj: String::from(""), + kk: ObjectA::new(), + l: Vec::new(), + ll: Vec::new(), + lll: Vec::new(), + llll: Vec::new(), + m: HashMap::new(), + mm: HashMap::new(), + s: HashSet::new(), + ssss: HashSet::new(), + outCompatibleValue: 0, + outCompatibleValue2: 0, + }; + return packet; + } +} + +pub fn writeNormalObject(buffer: &mut dyn IByteBuffer, packet: &dyn Any) { + let message = packet.downcast_ref::().unwrap(); + 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.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.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); + } + } + 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()); + } + } + 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()); + } + } + buffer.writeInt(message.outCompatibleValue); + buffer.writeInt(message.outCompatibleValue2); + buffer.adjustPadding(857, beforeWriteIndex); +} + +pub fn readNormalObject(buffer: &mut dyn IByteBuffer) -> Box { + let length = buffer.readInt(); + let mut packet = NormalObject::new(); + if length == 0 { + return Box::new(packet); + } + let beforeReadIndex = buffer.getReadOffset(); + let result0 = buffer.readByte(); + packet.a = result0; + let mut result1: Vec = Vec::new(); + let size3 = buffer.readInt(); + if size3 > 0 { + for index2 in 0 .. size3 { + let result4 = buffer.readByte(); + result1.push(result4); + } + } + 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::().unwrap().clone(); + packet.kk = result13; + let mut result14: Vec = Vec::new(); + let size15 = buffer.readInt(); + if size15 > 0 { + for index16 in 0 .. size15 { + let result17 = buffer.readInt(); + result14.push(result17); + } + } + packet.l = result14; + let mut result18: Vec = 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 = Vec::new(); + let size23 = buffer.readInt(); + if size23 > 0 { + for index24 in 0 .. size23 { + let result25 = buffer.readPacket(102); + let result26 = result25.downcast_ref::().unwrap().clone(); + result22.push(result26); + } + } + packet.lll = result22; + let mut result27: Vec = 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 = 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 = 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::().unwrap().clone(); + result36.insert(result39, result41); + } + } + packet.mm = result36; + let mut result42: HashSet = 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 = HashSet::new(); + let size47 = buffer.readInt(); + if size47 > 0 { + for index48 in 0 .. size47 { + let result49 = buffer.readString(); + result46.insert(result49); + } + } + packet.ssss = result46; + if buffer.compatibleRead(beforeReadIndex, length) { + let result50 = buffer.readInt(); + packet.outCompatibleValue = result50; + } + if buffer.compatibleRead(beforeReadIndex, length) { + let result51 = buffer.readInt(); + packet.outCompatibleValue2 = result51; + } + if length > 0 { + buffer.setReadOffset(beforeReadIndex + length); + } + return Box::new(packet); +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/objectA.rs b/protocol/src/test/rust/zfoorust/objectA.rs new file mode 100644 index 00000000..5c7facaf --- /dev/null +++ b/protocol/src/test/rust/zfoorust/objectA.rs @@ -0,0 +1,88 @@ +#![allow(dead_code)] +#![allow(unused_imports)] +#![allow(unused_mut)] +#![allow(unused_variables)] +#![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, IPacket}; +use crate::zfoorust::objectB::ObjectB; + +#[derive(Clone)] +pub struct ObjectA { + pub a: i32, + pub m: HashMap, + pub objectB: ObjectB, + pub innerCompatibleValue: i32, +} + +impl IPacket for ObjectA { + fn protocolId(&self) -> i16 { + return 102; + } +} + +impl ObjectA { + pub fn new() -> ObjectA { + let packet = ObjectA { + a: 0, + m: HashMap::new(), + objectB: ObjectB::new(), + innerCompatibleValue: 0, + }; + return packet; + } +} + +pub fn writeObjectA(buffer: &mut dyn IByteBuffer, packet: &dyn Any) { + let message = packet.downcast_ref::().unwrap(); + 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.writePacket(&message.objectB, 103); + buffer.writeInt(message.innerCompatibleValue); + buffer.adjustPadding(201, beforeWriteIndex); +} + +pub fn readObjectA(buffer: &mut dyn IByteBuffer) -> Box { + let length = buffer.readInt(); + let mut packet = ObjectA::new(); + if length == 0 { + return Box::new(packet); + } + let beforeReadIndex = buffer.getReadOffset(); + let result0 = buffer.readInt(); + packet.a = result0; + let mut result1: HashMap = 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::().unwrap().clone(); + packet.objectB = result7; + if buffer.compatibleRead(beforeReadIndex, length) { + let result8 = buffer.readInt(); + packet.innerCompatibleValue = result8; + } + if length > 0 { + buffer.setReadOffset(beforeReadIndex + length); + } + return Box::new(packet); +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/objectB.rs b/protocol/src/test/rust/zfoorust/objectB.rs new file mode 100644 index 00000000..90948232 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/objectB.rs @@ -0,0 +1,61 @@ +#![allow(dead_code)] +#![allow(unused_imports)] +#![allow(unused_mut)] +#![allow(unused_variables)] +#![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, IPacket}; + + +#[derive(Clone)] +pub struct ObjectB { + pub flag: bool, + pub innerCompatibleValue: i32, +} + +impl IPacket for ObjectB { + fn protocolId(&self) -> i16 { + return 103; + } +} + +impl ObjectB { + pub fn new() -> ObjectB { + let packet = ObjectB { + flag: false, + innerCompatibleValue: 0, + }; + return packet; + } +} + +pub fn writeObjectB(buffer: &mut dyn IByteBuffer, packet: &dyn Any) { + let message = packet.downcast_ref::().unwrap(); + let beforeWriteIndex = buffer.getWriteOffset(); + buffer.writeInt(4); + buffer.writeBool(message.flag); + buffer.writeInt(message.innerCompatibleValue); + buffer.adjustPadding(4, beforeWriteIndex); +} + +pub fn readObjectB(buffer: &mut dyn IByteBuffer) -> Box { + let length = buffer.readInt(); + let mut packet = ObjectB::new(); + if length == 0 { + return Box::new(packet); + } + let beforeReadIndex = buffer.getReadOffset(); + let result0 = buffer.readBool(); + packet.flag = result0; + if buffer.compatibleRead(beforeReadIndex, length) { + let result1 = buffer.readInt(); + packet.innerCompatibleValue = result1; + } + if length > 0 { + buffer.setReadOffset(beforeReadIndex + length); + } + return Box::new(packet); +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/protocol_manager.rs b/protocol/src/test/rust/zfoorust/protocol_manager.rs new file mode 100644 index 00000000..523f2331 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/protocol_manager.rs @@ -0,0 +1,45 @@ +#![allow(unused_imports)] +#![allow(dead_code)] +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] +use std::any::Any; +use crate::zfoorust::i_byte_buffer::IByteBuffer; +use crate::zfoorust::emptyObject::{writeEmptyObject, readEmptyObject}; +use crate::zfoorust::normalObject::{writeNormalObject, readNormalObject}; +use crate::zfoorust::objectA::{writeObjectA, readObjectA}; +use crate::zfoorust::objectB::{writeObjectB, readObjectB}; +use crate::zfoorust::simpleObject::{writeSimpleObject, readSimpleObject}; + + +pub fn write(buffer: &mut dyn IByteBuffer, packet: &dyn Any, protocolId: i16) { + buffer.writeShort(protocolId); + writeNoProtocolId(buffer, packet, protocolId); +} + +pub fn writeNoProtocolId(buffer: &mut dyn IByteBuffer, packet: &dyn Any, protocolId: i16) { + match protocolId { + 0 => writeEmptyObject(buffer, packet), + 101 => writeNormalObject(buffer, packet), + 102 => writeObjectA(buffer, packet), + 103 => writeObjectB(buffer, packet), + 104 => writeSimpleObject(buffer, packet), + _ => println!("protocolId:[{}] not found", protocolId) + } +} + +pub fn read(buffer: &mut dyn IByteBuffer) -> Box { + let protocolId = buffer.readShort(); + return readNoProtocolId(buffer, protocolId); +} + +pub fn readNoProtocolId(buffer: &mut dyn IByteBuffer, protocolId: i16) -> Box { + let packet = match protocolId { + 0 => readEmptyObject(buffer), + 101 => readNormalObject(buffer), + 102 => readObjectA(buffer), + 103 => readObjectB(buffer), + 104 => readSimpleObject(buffer), + _ => Box::new(String::from("protocolId not found")) + }; + return packet; +} \ No newline at end of file diff --git a/protocol/src/test/rust/zfoorust/simpleObject.rs b/protocol/src/test/rust/zfoorust/simpleObject.rs new file mode 100644 index 00000000..dac16b05 --- /dev/null +++ b/protocol/src/test/rust/zfoorust/simpleObject.rs @@ -0,0 +1,57 @@ +#![allow(dead_code)] +#![allow(unused_imports)] +#![allow(unused_mut)] +#![allow(unused_variables)] +#![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, IPacket}; + + +#[derive(Clone)] +pub struct SimpleObject { + pub c: i32, + pub g: bool, +} + +impl IPacket for SimpleObject { + fn protocolId(&self) -> i16 { + return 104; + } +} + +impl SimpleObject { + pub fn new() -> SimpleObject { + let packet = SimpleObject { + c: 0, + g: false, + }; + return packet; + } +} + +pub fn writeSimpleObject(buffer: &mut dyn IByteBuffer, packet: &dyn Any) { + let message = packet.downcast_ref::().unwrap(); + buffer.writeInt(-1); + buffer.writeInt(message.c); + buffer.writeBool(message.g); +} + +pub fn readSimpleObject(buffer: &mut dyn IByteBuffer) -> Box { + let length = buffer.readInt(); + let mut packet = SimpleObject::new(); + if length == 0 { + return Box::new(packet); + } + let beforeReadIndex = buffer.getReadOffset(); + let result0 = buffer.readInt(); + packet.c = result0; + let result1 = buffer.readBool(); + packet.g = result1; + if length > 0 { + buffer.setReadOffset(beforeReadIndex + length); + } + return Box::new(packet); +} \ No newline at end of file