Struct wasmer_cache::FileSystemCache

pub struct FileSystemCache { /* fields omitted */ }

Representation of a directory that contains compiled wasm artifacts.

The FileSystemCache type implements the Cache trait, which allows it to be used generically when some sort of cache is required.

Usage

use wasmer::{DeserializeError, SerializeError};
use wasmer_cache::{Cache, FileSystemCache, Hash};

fn store_module(module: &Module, bytes: &[u8]) -> Result<(), SerializeError> {
    // Create a new file system cache.
    let mut fs_cache = FileSystemCache::new("some/directory/goes/here")?;

    // Compute a key for a given WebAssembly binary
    let key = Hash::generate(bytes);

    // Store a module into the cache given a key
    fs_cache.store(key, module)?;

    Ok(())
}

Implementations

impl FileSystemCache

pub fn new<P: Into<PathBuf>>(path: P) -> Result<Self>

Construct a new FileSystemCache around the specified directory.

pub fn set_cache_extension(&mut self, ext: Option<impl ToString>)

Set the extension for this cached file.

This is needed for loading native files from Windows, as otherwise loading the library will fail (it requires a .dll extension)

Trait Implementations

impl Cache for FileSystemCache

type DeserializeError = DeserializeError

The deserialization error for the implementation

type SerializeError = SerializeError

The serialization error for the implementation

pub unsafe fn load(
    &self,
    store: &Store,
    key: Hash
) -> Result<Module, Self::DeserializeError>

Loads a module using the provided Store and [Hash].

pub fn store(
    &mut self,
    key: Hash,
    module: &Module
) -> Result<(), Self::SerializeError>

Store a Module into the cache with the given [Hash].