include!("./gen/data.rs");

#[derive(Clone, Debug, Hash, PartialEq)]
pub struct Native {
    pub a: i32,
    pub b: i32,
}

#[derive(Clone, Debug, Hash, PartialEq)]
pub struct GenericNative<A, B> {
    pub a: A,
    pub b: B,
}


pub mod transient_0 {
    use ::std::any::Any;
    use ::std::sync::Arc;
    use ::std::vec::Vec;
    use super::{GenericNative, Native};

    include!("./gen/data/transient_0.rs");

    pub fn encode_native(
        value: &Native,
        writer: &mut impl std::io::Write,
        shared_values: &mut ::std::collections::HashMap::<usize, i64>,
    ) -> std::io::Result<()> {
        crate::transient_0::encode_int_32(&value.a, writer, shared_values)?;
        crate::transient_0::encode_int_32(&value.b, writer, shared_values)?;
        Ok(())
    }

    pub fn decode_native(
        reader: &mut impl std::io::Read,
        shared_values: &mut Vec<Arc::<dyn Any + Sync + Send>>,
    ) -> std::io::Result<Native> {
        let a = crate::transient_0::decode_int_32(reader, shared_values)?;
        let b = crate::transient_0::decode_int_32(reader, shared_values)?;
        Ok(Native { a, b })
    }

    type Encode<T, TWrite: std::io::Write> = fn(
        &T,
        &mut TWrite,
        &mut ::std::collections::HashMap::<usize, i64>,
    ) -> std::io::Result<()>;

    type Decode<TRead: std::io::Read, T> = fn(
        &mut TRead,
        &mut Vec<Arc::<dyn Any + Sync + Send>>,
    ) -> std::io::Result<T>;

    pub fn encode_generic_native<TWrite: std::io::Write, A, B>(
        value: &GenericNative<A, B>,
        writer: &mut TWrite,
        shared_values: &mut ::std::collections::HashMap::<usize, i64>,
        encode_a: Encode<A, TWrite>,
        encode_b: Encode<B, TWrite>,
    ) -> std::io::Result<()> {
        encode_a(&value.a, writer, shared_values)?;
        encode_b(&value.b, writer, shared_values)?;
        Ok(())
    }

    pub fn decode_generic_native<TRead: std::io::Read, A, B>(
        reader: &mut TRead,
        shared_values: &mut Vec<Arc::<dyn Any + Sync + Send>>,
        decode_a: Decode<TRead, A>,
        decode_b: Decode<TRead, B>,
    ) -> std::io::Result<GenericNative<A, B>> {
        let a = decode_a(reader, shared_values)?;
        let b = decode_b(reader, shared_values)?;
        Ok(GenericNative { a, b })
    }
}