Struct FileSystemCache

pub struct FileSystemCache { /* private fields */ }

Available on crate feature filesystem only.

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

unsafe fn load( &self, engine: &impl AsEngineRef, key: Hash, ) -> Result<Module, Self::DeserializeError>

Loads a module using the provided wasmer::Store and crate::Hash.

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

Store a Module into the cache with the given crate::Hash.

impl Clone for FileSystemCache

fn clone(&self) -> FileSystemCache

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileSystemCache

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

Formats the value using the given formatter.