epserde 0.13.1

/*
 * SPDX-FileCopyrightText: 2023 Inria
 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 */

//! Example of a nested struct in which one of the fields of the inner struct is
//! recursively ε-copied, as its type is a parameter. We also serialize on file.
//!
//! When deserializing, we show three variants: one in which both parameters are
//! `Vec`, one in which the outer parameter is a boxed slice and the inner
//! parameter is a `Vec`, and one in which both parameters are boxed slices.
//!
//! Please compile with the "schema" feature to see the schema output.

#[cfg(not(feature = "std"))]
fn main() {
    println!("This example requires the standard library");
}

#[cfg(feature = "std")]
use epserde::{deser::DeserType, prelude::*, ser::SerType};

#[cfg(feature = "std")]
#[derive(Epserde, Debug, PartialEq, Eq, Default, Clone)]
struct StructParam<A, B> {
    a: A,
    b: B,
    test: isize,
}

#[cfg(feature = "std")]
#[derive(Epserde, Debug, PartialEq, Eq, Default, Clone)]
struct Data<A> {
    a: A,
    /// This is a field whose type is not a parameter,
    /// so it will not be ε-copied, but rather fully copied.
    b: Vec<i32>,
}

#[cfg(feature = "std")]
type Type = StructParam<Vec<usize>, Data<Vec<u16>>>;
#[cfg(feature = "std")]
type TypeOneBoxed = StructParam<Box<[usize]>, Data<Vec<u16>>>;
#[cfg(feature = "std")]
type TypeBothBoxed = StructParam<Box<[usize]>, Data<Box<[u16]>>>;

#[cfg(feature = "std")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A unique path in the temporary directory, so the example does not
    // litter the working directory.
    let file_name = std::env::temp_dir().join(format!("epserde_nested_{}.bin", std::process::id()));
    // Remove the file even if run returns early with an error.
    let result = run(&file_name);
    let _ = std::fs::remove_file(&file_name);
    result
}

#[cfg(feature = "std")]
fn run(file_name: &std::path::Path) -> Result<(), Box<dyn std::error::Error>> {
    println!("Serializing type: {}", core::any::type_name::<Type>());
    println!(
        "Associated serialization type: {}",
        core::any::type_name::<SerType<Type>>()
    );
    println!();

    // Create a new value to serialize
    let data = Type {
        a: vec![0x1; 4],
        b: Data {
            a: vec![0x2; 7],
            b: vec![0xbadf00d; 2],
        },
        test: -0xbadf00d,
    };
    let mut file = std::fs::File::create(file_name)?;

    // Serialize
    #[cfg(feature = "schema")]
    {
        let schema = unsafe { data.serialize_with_schema(&mut file)? };
        println!("{}", schema.to_csv_with_data(&std::fs::read(file_name)?));
        println!();
    }
    #[cfg(not(feature = "schema"))]
    let _bytes_written = unsafe { data.serialize(&mut file)? };

    drop(file);

    // Do a full-copy deserialization with vectors
    let mut file = std::fs::File::open(file_name)?;
    let full = unsafe { Type::deserialize_full(&mut file)? };
    println!(
        "Full-copy deserialization: returns the deserializing type {}",
        core::any::type_name::<Type>(),
    );
    println!("Value: {:x?}", full);
    assert_eq!(data, full);

    println!();

    // Do a full-copy deserialization with one boxed slice
    let mut file = std::fs::File::open(file_name)?;
    let full = unsafe { TypeOneBoxed::deserialize_full(&mut file)? };
    println!(
        "Full-copy deserialization: returns the deserializing type {}",
        core::any::type_name::<TypeOneBoxed>(),
    );
    println!("Value: {:x?}", full);

    println!();

    // Do a full-copy deserialization with boxed slices
    let mut file = std::fs::File::open(file_name)?;
    let full = unsafe { TypeBothBoxed::deserialize_full(&mut file)? };
    println!(
        "Full-copy deserialization: returns the deserializing type {}",
        core::any::type_name::<TypeBothBoxed>(),
    );
    println!("Value: {:x?}", full);

    println!();

    // Do an ε-copy deserialization
    let file = std::fs::read(file_name)?;
    let eps = unsafe { Type::deserialize_eps(&file)? };
    println!(
        "ε-copy deserialization: returns the associated deserialization type {}",
        core::any::type_name::<DeserType<'_, Type>>(),
    );
    println!("Value: {:x?}", eps);
    assert_eq!(data.a, eps.a);
    assert_eq!(data.b.a, eps.b.a);
    assert_eq!(data.b.b, eps.b.b);
    assert_eq!(data.test, eps.test);

    #[cfg(not(feature = "schema"))]
    println!("\nPlease compile with the \"schema\" feature to see the schema output");
    Ok(())
}