Struct MessageCompressor 

pub struct MessageCompressor {
    CompressionLevel: u32,
    BatchSize: usize,
}

Message compression utility for optimizing IPC message transfer

This structure provides Gzip-based compression to reduce the size of IPC messages, improving transfer speed and reducing bandwidth usage.

Compression Flow

Multiple TauriIPCMessage
    |
    | 1. Serialize to JSON
    v
Serialized JSON bytes
    |
    | 2. Compress with Gzip
    v
Compressed bytes (smaller)
    |
    | 3. Base64 encode for transport
    v
Base64 string (sendable via IPC)

Decompression Flow

Base64 string (received via IPC)
    |
    | 1. Base64 decode
    v
Compressed bytes
    |
    | 2. Decompress with Gzip
    v
Serialized JSON bytes
    |
    | 3. Deserialize to TauriIPCMessage[]
    v
Multiple TauriIPCMessage

Compression Levels

Compression levels range from 0 (fastest, no compression) to 9 (slowest, best compression). The recommended level is 6 for a good balance.

Level	Speed	Ratio	Use Case
0	Fastest	1:1	Testing/debugging
1-3	Fast	2:1-3:1	Real-time systems
4-6	Medium	3:1-5:1	General use
7-9	Slow	5:1-7:1	Bandwidth-constrained

Example Usage

let compressor = MessageCompressor::new(6, 10);

// Compress messages
let messages = vec![message1, message2, message3];
let compressed = compressor.compress_messages(messages)?;

// Decompress messages
let decompressed = compressor.decompress_messages(&compressed)?;

Fields

CompressionLevel: u32

Gzip compression level (0-9, where 0 is no compression)

BatchSize: usize

Minimum number of messages required for batch processing

Implementations

impl MessageCompressor

pub fn new(CompressionLevel: u32, BatchSize: usize) -> Self

Create a new message compressor with specified parameters

Parameters

• CompressionLevel: Gzip compression level (0-9, default 6)
• BatchSize: Minimum messages for batch processing (default 10)

Example

let compressor = MessageCompressor::new(6, 10);

pub fn compress_messages( &self, Messages: Vec<TauriIPCMessage>, ) -> Result<Vec<u8>, String>

Compress messages using Gzip for efficient transfer

This method serializes multiple messages to JSON and compresses them using Gzip, significantly reducing the payload size.

Parameters

• Messages: Vector of TauriIPCMessage to compress

Returns

• Ok(Vec<u8>): Compressed message data
• Err(String): Error message if compression fails

Example

let messages = vec![msg1, msg2, msg3];
let compressed = compressor.compress_messages(messages)?;

pub fn decompress_messages( &self, CompressedData: &[u8], ) -> Result<Vec<TauriIPCMessage>, String>

Decompress messages from compressed data

This method decompresses Gzip-compressed data and deserializes it back into TauriIPCMessage objects.

Parameters

• CompressedData: Compressed message data

Returns

• Ok(Vec<TauriIPCMessage>): Decompressed messages
• Err(String): Error message if decompression fails

Example

let messages = compressor.decompress_messages(&compressed_data)?;

pub fn should_batch(&self, MessagesCount: usize) -> bool

Check if messages should be batched for compression

This method determines if the number of messages meets the threshold for batch compression.

Parameters

• MessagesCount: Number of messages to check

Returns

• true: Should batch (meets minimum threshold)
• false: Should not batch (below threshold)

Example

if compressor.should_batch(messages.len()) {
    // Batch compress
} else {
    // Send individually
}

pub fn compression_level(&self) -> u32

Get the compression level

pub fn batch_size(&self) -> usize

Get the batch size threshold

pub fn default() -> Self

Create a compressor with default settings (level 6, batch size 10)

pub fn fast() -> Self

Create a fast compressor (level 3, batch size 5)

pub fn max() -> Self

Create a maximum compression compressor (level 9, batch size 20)