Struct TexmfResources 

pub struct TexmfResources { /* private fields */ }

Resource provider backed by a TeXMF tree root and its ls-R filename index.

Implementations

impl TexmfResources

pub fn from_root(root: impl Into<PathBuf>) -> Option<Self>

Returns None when ls-R is absent or empty, run mktexlsr to generate it.

Examples found in repository

examples/pack_native_format.rs (line 81)

fn main() -> ExitCode {
    let Some(output) = output_path() else {
        eprintln!("usage: pack_native_format <output path>");
        return ExitCode::FAILURE;
    };
    let Some(texmf_root) = find_texmf_root() else {
        eprintln!("cannot find a texmf-dist ls-R index");
        return ExitCode::FAILURE;
    };
    let Some(texmf) = TexmfResources::from_root(texmf_root) else {
        eprintln!("cannot load the texmf-dist ls-R index");
        return ExitCode::FAILURE;
    };
    let texmf = Arc::new(texmf);

    let latex = match texmf.read("latex.ltx", ResourceKind::TexInput) {
        Ok(resource) => resource.bytes,
        Err(error) => {
            eprintln!("cannot read latex.ltx: {error:?}");
            return ExitCode::FAILURE;
        }
    };

    let cache = GeneratedFormatCache::initialized(pe::EngineProfile::xetex());
    let mut engine = cache
        .instantiate(
            pe::EngineProfile::xetex(),
            GeneratedResourceProvider::new(&*texmf),
        )
        .with_font_platform(GeneratedFontSystemAdapter::new(NativeFontSystem::new(
            texmf.clone(),
        )));

    if !engine.begin_primary_input("latex.ltx", latex) {
        eprintln!("failed to begin latex.ltx");
        return ExitCode::FAILURE;
    }
    engine.run_format_initialization();
    if !engine.begin_primary_input("preamble.tex", PREAMBLE.to_vec()) {
        eprintln!("failed to begin preamble");
        return ExitCode::FAILURE;
    }
    engine.run_format_initialization();

    engine.finalize_trie();
    let format_bytes = GeneratedFormatCache::from_engine(&engine).to_bytes();
    let font_table = engine.native_font_table();
    let packaged = mathtex_engine::generated::pack_packaged_format(&format_bytes, &font_table);
    if let Err(error) = std::fs::write(&output, packaged) {
        eprintln!("cannot write {}: {error}", output.display());
        return ExitCode::FAILURE;
    }
    ExitCode::SUCCESS
}

pub fn root(&self) -> &Path

Returns the filesystem root of the TeXMF tree.

pub fn len(&self) -> usize

Returns the number of basename entries in the ls-R index.

pub fn is_empty(&self) -> bool

Returns true when the ls-R index contains no entries.

Trait Implementations

impl Debug for TexmfResources

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ResourceProvider for TexmfResources

fn read_request( &self, request: &ResourceRequest, ) -> Result<Resource, ResourceError>

Resolve an arbitrary resource described by request.

fn read( &self, name: &str, kind: ResourceKind, ) -> Result<Resource, ResourceError>

Resolve name as a resource of the given kind.

fn read_tex_input(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a TeX input file by name.

fn read_package(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a LaTeX package file by name.

fn read_class(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a LaTeX class file by name.

fn read_font_definition(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a font definition file by name.

fn read_package_support(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a package support file by name.

fn read_font(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a font program or collection by name.

fn read_encoding(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a font encoding file by name.

fn read_map(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a font map file by name.

fn read_config(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a configuration file by name.

fn read_format_image(&self, name: &str) -> Result<Resource, ResourceError>

Resolve a precompiled format image by name.

fn read_asset( &self, package: &str, name: &str, ) -> Result<Resource, ResourceError>

Resolve a package-owned asset by package and asset name.