mirror of
https://github.com/tiennm99/zfoo.git
synced 2026-05-26 04:02:01 +00:00
test[rust]: protocol test
This commit is contained in:
godotg
@@ -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::<NormalObject>().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::<NormalObject>().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"));
|
||||
}
|
||||
@@ -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<i8>,
|
||||
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<i8> = 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<i8> {
|
||||
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<u8> {
|
||||
let mut bytes: Vec<u8> = 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<dyn Any> {
|
||||
return readNoProtocolId(self, protocolId);
|
||||
}
|
||||
}
|
||||
@@ -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::<EmptyObject>().unwrap();
|
||||
buffer.writeInt(-1);
|
||||
}
|
||||
|
||||
pub fn readEmptyObject(buffer: &mut dyn IByteBuffer) -> Box<dyn Any> {
|
||||
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);
|
||||
}
|
||||
@@ -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<i8>;
|
||||
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<u8>;
|
||||
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<dyn Any>;
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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<i8>,
|
||||
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<i32>,
|
||||
pub ll: Vec<i64>,
|
||||
pub lll: Vec<ObjectA>,
|
||||
pub llll: Vec<String>,
|
||||
pub m: HashMap<i32, String>,
|
||||
pub mm: HashMap<i32, ObjectA>,
|
||||
pub s: HashSet<i32>,
|
||||
pub ssss: HashSet<String>,
|
||||
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::<NormalObject>().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<dyn Any> {
|
||||
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<i8> = 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::<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.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;
|
||||
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);
|
||||
}
|
||||
@@ -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<i32, String>,
|
||||
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::<ObjectA>().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<dyn Any> {
|
||||
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<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;
|
||||
if buffer.compatibleRead(beforeReadIndex, length) {
|
||||
let result8 = buffer.readInt();
|
||||
packet.innerCompatibleValue = result8;
|
||||
}
|
||||
if length > 0 {
|
||||
buffer.setReadOffset(beforeReadIndex + length);
|
||||
}
|
||||
return Box::new(packet);
|
||||
}
|
||||
@@ -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::<ObjectB>().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<dyn Any> {
|
||||
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);
|
||||
}
|
||||
@@ -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<dyn Any> {
|
||||
let protocolId = buffer.readShort();
|
||||
return readNoProtocolId(buffer, protocolId);
|
||||
}
|
||||
|
||||
pub fn readNoProtocolId(buffer: &mut dyn IByteBuffer, protocolId: i16) -> Box<dyn Any> {
|
||||
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;
|
||||
}
|
||||
@@ -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::<SimpleObject>().unwrap();
|
||||
buffer.writeInt(-1);
|
||||
buffer.writeInt(message.c);
|
||||
buffer.writeBool(message.g);
|
||||
}
|
||||
|
||||
pub fn readSimpleObject(buffer: &mut dyn IByteBuffer) -> Box<dyn Any> {
|
||||
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);
|
||||
}
|
||||
Reference in New Issue
Block a user