graphblas_sparse_linear_algebra 0.62.0

use core::slice;
use std::{ffi::c_void, mem::MaybeUninit};

use suitesparse_graphblas_sys::{GrB_Index, GrB_Vector, GxB_Vector_serialize};

use crate::context::CallGraphBlasContext;
use crate::index::IndexConversion;
use crate::{
    collections::GetGraphblasSerializerDescriptor, context::GetContext,
    error::SparseLinearAlgebraError, index::ElementIndex,
};

pub trait SerializeSuitesparseGraphblasSparseVector {
    unsafe fn serialize_suitesparse_grapblas_sparse_vector(
        &self,
        graphblas_sparse_vector: GrB_Vector,
    ) -> Result<Vec<u8>, SparseLinearAlgebraError>;
}

pub unsafe fn serialize_suitesparse_grapblas_sparse_vector(
    serializer: &(impl GetGraphblasSerializerDescriptor + GetContext),
    suitesparse_graphblas_sparse_vector: GrB_Vector,
) -> Result<Vec<u8>, SparseLinearAlgebraError> {
    let mut size_of_serialized_vector: MaybeUninit<GrB_Index> = MaybeUninit::uninit();
    let mut serialized_vector_pointer: MaybeUninit<*mut c_void> = MaybeUninit::uninit();

    serializer.context_ref().call(
        || unsafe {
            GxB_Vector_serialize(
                serialized_vector_pointer.as_mut_ptr(),
                size_of_serialized_vector.as_mut_ptr(),
                suitesparse_graphblas_sparse_vector,
                serializer.graphblas_serializer_descriptor(),
            )
        },
        serializer.graphblas_serializer_descriptor_ref(),
    )?;

    let size_of_serialized_vector =
        ElementIndex::from_graphblas_index(unsafe { size_of_serialized_vector.assume_init() })?;
    let serialized_vector_pointer = unsafe { serialized_vector_pointer.assume_init() };

    let serialized_vector = unsafe {
        slice::from_raw_parts(
            serialized_vector_pointer as *const u8,
            size_of_serialized_vector,
        )
        .to_vec()
    };

    // NOTE: requires memory allocator to be compatibele with libc
    unsafe {
        libc::free(serialized_vector_pointer as *mut c_void);
    }

    Ok(serialized_vector)
}