Struct fuel_data_parser::DataParser

pub struct DataParser {
    pub serialization_type: SerializationType,
    /* private fields */
}

DataParser is a utility struct for encoding (compressing & serializing) and decoding (decompressing & deserializing) data. It is useful for optimizing memory usage and I/O bandwidth by applying different compression strategies and serialization formats.

Fields

• compression_strategy - An Arc to a CompressionStrategy trait object that defines the method of data compression.
• serialization_type - An enum that specifies the serialization format (e.g., Bincode, Postcard, JSON).

Examples

use fuel_data_parser::{DataParser, SerializationType};
use std::sync::Arc;

#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
struct TestData {
    field: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let parser = DataParser::default();

    let original_data = TestData { field: "test".to_string() };
    let encoded = parser.encode(&original_data).await?;
    let decoded: TestData = parser.decode(&encoded).await?;

    assert_eq!(original_data, decoded);
    Ok(())
}

Fields

serialization_type: SerializationType

Implementations

impl DataParser

pub fn with_compression_strategy( self, compression_strategy: &Arc<dyn CompressionStrategy>, ) -> Self

Sets the compression strategy for the DataParser.

Arguments

• compression_strategy - A reference to an Arc of a CompressionStrategy trait object.

Returns

A new instance of DataParser with the updated compression strategy.

Examples

use fuel_data_parser::{DataParser, DEFAULT_COMPRESSION_STRATEGY};
use std::sync::Arc;

let parser = DataParser::default()
    .with_compression_strategy(&DEFAULT_COMPRESSION_STRATEGY);

pub fn with_serialization_type( self, serialization_type: SerializationType, ) -> Self

Sets the serialization type for the DataParser.

Arguments

• serialization_type - A SerializationType enum specifying the desired serialization format.

Returns

A new instance of DataParser with the updated serialization type.

Examples

use fuel_data_parser::{DataParser, SerializationType};

let parser = DataParser::default()
    .with_serialization_type(SerializationType::Json);

pub async fn encode<T: DataParseable>(&self, data: &T) -> Result<Vec<u8>, Error>

Encodes the provided data by serializing and then compressing it.

Arguments

• data - A reference to a data structure implementing the DataParseable trait.

Returns

A Result containing either a Vec<u8> of the compressed, serialized data, or an Error if encoding fails.

Examples

use fuel_data_parser::DataParser;

#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
struct TestData {
    field: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let parser = DataParser::default();
    let data = TestData { field: "test".to_string() };
    let encoded = parser.encode(&data).await?;
    assert!(!encoded.is_empty());
    Ok(())
}

pub async fn serialize<T: DataParseable>( &self, raw_data: &T, ) -> Result<Vec<u8>, Error>

Serializes the provided data according to the selected SerializationType.

Arguments

• raw_data - A reference to a data structure implementing the DataParseable trait.

Returns

A Result containing either a Vec<u8> of the serialized data, or an Error if serialization fails.

pub async fn decode<T: DataParseable>(&self, data: &[u8]) -> Result<T, Error>

Decodes the provided data by decompressing and then deserializing it.

Arguments

• data - A byte slice (&[u8]) representing the compressed, serialized data.

Returns

A Result containing either the deserialized data structure, or an Error if decoding fails.

Examples

use fuel_data_parser::DataParser;

#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
struct TestData {
    field: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let parser = DataParser::default();
    let original_data = TestData { field: "test".to_string() };
    let encoded = parser.encode(&original_data).await?;
    let decoded: TestData = parser.decode(&encoded).await?;
    assert_eq!(original_data, decoded);
    Ok(())
}

pub async fn deserialize<'a, T: Deserialize<'a>>( &self, raw_data: &'a [u8], ) -> Result<T, Error>

Deserializes the provided data according to the selected SerializationType.

Arguments

• raw_data - A byte slice (&[u8]) representing the serialized data.

Returns

A Result containing either the deserialized data structure, or an Error if deserialization fails.

Trait Implementations

impl Clone for DataParser

fn clone(&self) -> DataParser

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for DataParser

fn default() -> Self

Provides a default instance of DataParser with default compression strategy and SerializationType::Postcard.

Examples

use fuel_data_parser::{DataParser, SerializationType};

let parser = DataParser::default();
assert!(matches!(parser.serialization_type, SerializationType::Postcard));