majorsilence-reporting

Instalación

El crate aún no está publicado en crates.io. Añádelo como dependencia de ruta (path):

# Cargo.toml
[dependencies]
majorsilence-reporting = { path = "/path/to/reporting-rust" }

# Una vez publicado en crates.io:
# majorsilence-reporting = "1.0"

La única dependencia en tiempo de ejecución es libloading = "0.8". Edición 2021 de Rust, versión mínima 1.65.

Inicio rápido

use majorsilence_reporting::RdlLibrary;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Cargar la biblioteca nativa una vez por proceso.
    let lib = RdlLibrary::load("/path/to/rdlnative/librdlnative.so")?;

    // Construir una configuración de informe.
    let mut rpt = lib.report("/path/to/report.rdl");
    rpt.set_connection_string("Data Source=/path/to/northwindEF.db")
       .set_parameter("Country", "Germany");

    // Exportar a un archivo.
    rpt.export("pdf", "/tmp/output.pdf")?;

    // O exportar a memoria — no se escribe ningún archivo temporal.
    let pdf_bytes: Vec<u8> = rpt.export_to_memory("pdf")?;
    println!("Se obtuvieron {} bytes", pdf_bytes.len());

    Ok(())
}

Carga de la biblioteca

RdlLibrary::load realiza toda la configuración necesaria: define RDLNATIVE_LIB_DIR, precarga los archivos .so / .dylib asociados con RTLD_GLOBAL para que el resolutor P/Invoke de .NET pueda encontrarlos, resuelve todos los símbolos FFI, y llama a rdl_init().

use majorsilence_reporting::RdlLibrary;

// Llamar una vez al iniciar el proceso. RdlLibrary está respaldado por Arc — clonación económica y Send + Sync.
let lib = RdlLibrary::load("/path/to/librdlnative.so")?;

// Clonarlo entre hilos (por ejemplo en un estado de Axum o Data de Actix)
let lib2 = lib.clone();
std::thread::spawn(move || {
    let mut rpt = lib2.report("/path/to/report.rdl");
    rpt.export("pdf", "/tmp/thread.pdf").unwrap();
});

API principal

Los métodos constructores devuelven &mut Self para permitir encadenamiento. Se abre y se cierra un nuevo handle de informe nativo en cada llamada a export o export_to_memory, por lo que un valor Report puede reutilizarse en varios renderizados.

Conjuntos de datos en memoria

Pasa datos estructurados directamente al informe sin necesidad de una base de datos. Cada fila es un HashMap<String, String> cuyas claves son los nombres de columna y cuyos valores son los campos codificados como cadenas.

use std::collections::HashMap;
use majorsilence_reporting::RdlLibrary;

let lib = RdlLibrary::load("/path/to/librdlnative.so")?;
let mut rpt = lib.report("/path/to/report.rdl");

let rows: Vec<HashMap<String, String>> = vec![
    [("Product", "PDF Library Pro"), ("Revenue", "1200.00"), ("Units", "3")]
        .iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
    [("Product", "Report Designer"),  ("Revenue", "250.00"),  ("Units", "1")]
        .iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
];

rpt.add_data("SalesData", rows);
let pdf = rpt.export_to_memory("pdf")?;

Exportar a memoria

export_to_memory llama a la función FFI nativa rdl_report_render_buffer, que rellena un búfer asignado del lado nativo y devuelve un puntero y una longitud. El wrapper de Rust copia los bytes en un Vec<u8> y llama a rdl_free. No se escribe ningún archivo temporal en ningún momento — útil para cuerpos de respuesta HTTP o integración en pipelines.

// Ejemplo de handler de Axum
async fn report_handler(State(lib): State<RdlLibrary>) -> impl IntoResponse {
    let mut rpt = lib.report("/reports/sales.rdl");
    rpt.set_connection_string("Data Source=/data/northwindEF.db");

    match rpt.export_to_memory("pdf") {
        Ok(bytes) => (
            StatusCode::OK,
            [("content-type", "application/pdf")],
            bytes,
        ).into_response(),
        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response(),
    }
}

Gestión de errores

Todas las operaciones que pueden fallar devuelven Result<T, majorsilence_reporting::Error>. Error implementa std::error::Error y encapsula el mensaje devuelto por la función nativa rdl_last_error().

match rpt.export_to_memory("pdf") {
    Ok(bytes) => { /* usar bytes */ }
    Err(e)    => eprintln!("fallo al renderizar: {e}"),
}

// O propagar con ?
let bytes = rpt.export_to_memory("pdf")?;

Formatos de exportación

Se admiten los diez formatos. A diferencia de los modos de subproceso de Python/PHP/Ruby, todos los formatos están disponibles en el wrapper de Rust porque siempre usa la vía FFI nativa.