Trait ResourceProvider

Source

pub trait ResourceProvider {
Show 13 methods    // Required method
    fn read_request(
        &self,
        request: &ResourceRequest,
    ) -> Result<Resource, ResourceError>;

    // Provided methods
    fn read(
        &self,
        name: &str,
        kind: ResourceKind,
    ) -> Result<Resource, ResourceError> { ... }
    fn read_tex_input(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_package(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_class(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_font_definition(
        &self,
        name: &str,
    ) -> Result<Resource, ResourceError> { ... }
    fn read_package_support(
        &self,
        name: &str,
    ) -> Result<Resource, ResourceError> { ... }
    fn read_font(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_encoding(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_map(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_config(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_format_image(&self, name: &str) -> Result<Resource, ResourceError> { ... }
    fn read_asset(
        &self,
        package: &str,
        name: &str,
    ) -> Result<Resource, ResourceError> { ... }
}

Expand description

Resolves TeX inputs, packages, fonts, encodings, maps, and config assets.

Required Methods§

Source

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

Resolve an arbitrary resource described by request.

Provided Methods§

Source

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

Resolve name as a resource of the given kind.

Examples found in repository ?

examples/pack_native_format.rs (line 46)

44    fn read_request(&self, request: &ResourceRequest) -> Result<Resource, ResourceError> {
45        let name = Self::font_name(&request.canonical_name());
46        self.texmf.read(&name, ResourceKind::Font)
47    }
48}
49
50struct NativeFontSystem {
51    inner: RustybuzzFontSystem<ResourceFontSystem<TexmfFontProvider>>,
52}
53
54impl NativeFontSystem {
55    fn new(texmf: Arc<TexmfResources>) -> Self {
56        Self {
57            inner: RustybuzzFontSystem::new(ResourceFontSystem::new(TexmfFontProvider { texmf })),
58        }
59    }
60}
61
62impl FontSystem for NativeFontSystem {
63    fn load_font(&self, query: &FontQuery) -> Result<FontData, FontError> {
64        self.inner.load_font(query)
65    }
66
67    fn shape_text(&self, request: &ShapeRequest<'_>) -> Result<ShapedText, FontError> {
68        self.inner.shape_text(request)
69    }
70}
71
72fn main() -> ExitCode {
73    let Some(output) = output_path() else {
74        eprintln!("usage: pack_native_format <output path>");
75        return ExitCode::FAILURE;
76    };
77    let Some(texmf_root) = find_texmf_root() else {
78        eprintln!("cannot find a texmf-dist ls-R index");
79        return ExitCode::FAILURE;
80    };
81    let Some(texmf) = TexmfResources::from_root(texmf_root) else {
82        eprintln!("cannot load the texmf-dist ls-R index");
83        return ExitCode::FAILURE;
84    };
85    let texmf = Arc::new(texmf);
86
87    let latex = match texmf.read("latex.ltx", ResourceKind::TexInput) {
88        Ok(resource) => resource.bytes,
89        Err(error) => {
90            eprintln!("cannot read latex.ltx: {error:?}");
91            return ExitCode::FAILURE;
92        }
93    };
94
95    let cache = GeneratedFormatCache::initialized(pe::EngineProfile::xetex());
96    let mut engine = cache
97        .instantiate(
98            pe::EngineProfile::xetex(),
99            GeneratedResourceProvider::new(&*texmf),
100        )
101        .with_font_platform(GeneratedFontSystemAdapter::new(NativeFontSystem::new(
102            texmf.clone(),
103        )));
104
105    if !engine.begin_primary_input("latex.ltx", latex) {
106        eprintln!("failed to begin latex.ltx");
107        return ExitCode::FAILURE;
108    }
109    engine.run_format_initialization();
110    if !engine.begin_primary_input("preamble.tex", PREAMBLE.to_vec()) {
111        eprintln!("failed to begin preamble");
112        return ExitCode::FAILURE;
113    }
114    engine.run_format_initialization();
115
116    engine.finalize_trie();
117    let format_bytes = GeneratedFormatCache::from_engine(&engine).to_bytes();
118    let font_table = engine.native_font_table();
119    let packaged = mathtex_engine::generated::pack_packaged_format(&format_bytes, &font_table);
120    if let Err(error) = std::fs::write(&output, packaged) {
121        eprintln!("cannot write {}: {error}", output.display());
122        return ExitCode::FAILURE;
123    }
124    ExitCode::SUCCESS
125}