C'è un modo per includere file binari o di testo in una libreria Rust?

Question

Sto provando a creare una libreria e voglio includere alcuni file binari (o di testo) che avranno dati che verranno analizzati in fase di esecuzione.

La mia intenzione è di avere il controllo di questi file, aggiornarli costantemente e modificare la versione della libreria in ogni aggiornamento.

È possibile tramite carico? In tal caso, come posso accedere a questi file dalla mia biblioteca?

Una soluzione che ho pensato è quella di includere alcuni file .rs con strutture e/o costanti come &str che memorizzeranno i dati ma trovo un po 'brutto

EDIT:

ho cambiato la risposta accettata per quello che si adatta di più il mio caso, ma dare un'occhiata a Shepmaster's answer come questo può essere più adatto nel vostro caso.

Answer 1

Disclaimer: ho parlato in un commento, ma mi permetta di ribadire qui, in quanto mi dà più spazio per elaborare.

Come ha detto Shepmaster, è possibile includere testo o binari testualmente in una libreria di Rust/eseguibile utilizzando le include_bytes! e include_str! macro.

Nel tuo caso, tuttavia, lo eviterei. Rimandando l'analisi del contenuto in fase di esecuzione:

• consente di creare un artefatto difettoso.
• si verificano (più) tempo di esecuzione (tempo di analisi).
• si incorrere (più) spazio in testa (codice di analisi).

ruggine riconosce questo problema e offre molteplici meccanismi di generazione di codice destinata a superare queste limitazioni:

• macro: se la logica può essere codificato in una macro, allora può essere inclusa in una sorgente file direttamente
• plugin: alimentati fino macro, che possono codificare qualsiasi logica arbitraria e generare il codice elaborato (vedi regex!)
• build.rs: un "copione Ruggine" indipendente in esecuzione in vista della compilazione corretta il cui ruolo è quello di ge nerate .rs file

Nel tuo caso, lo script build.rs suona come una buona misura:

• spostando il codice di analisi lì, si esprime un manufatto più leggero
• analizzando prima del tempo, si fornire un manufatto più veloce
• analizzando prima del tempo, si trasporta una corretta artefatto

Il risultato della tua analisi può essere codificato in diversi modi, dalle funzioni alla statica (eventualmente lazy_static!), poiché build.rs può generare qualsiasi codice Rust valido.

È possibile vedere come utilizzare build.rs in the Cargo Documentation; troverai lì come integrarlo con Cargo e come creare file (e altro).

Answer 2

La macro include_bytes! sembra vicina a ciò che si desidera. Ti dà solo un riferimento ad un array di byte, però, in modo che avrebbe dovuto fare qualsiasi analisi a partire da quel:

static HOST_FILE: &'static [u8] = include_bytes!("/etc/hosts"); 

fn main() { 
    let host_str = std::str::from_utf8(HOST_FILE).unwrap(); 

    println!("Hosts are:\n{}", &host_str[..42]); 
} 

Se si dispone di UTF-8 di contenuti, è possibile utilizzare include_str!, come sottolineato da Benjamin Lindley :

static HOST_FILE: &'static str = include_str!("/etc/hosts"); 

fn main() { 
    println!("Hosts are:\n{}", &HOST_FILE[..42]); 
}