Struct wasmer_compiler::engine::builder::EngineBuilder

pub struct EngineBuilder {
    compiler_config: Option<Box<dyn CompilerConfig>>,
    target: Option<Target>,
    features: Option<Features>,
    hash_algorithm: Option<HashAlgorithm>,
}

The Builder contents of Engine

Fields

compiler_config: Option<Box<dyn CompilerConfig>>

The compiler

target: Option<Target>

The machine target

features: Option<Features>

The features to compile the Wasm module with

hash_algorithm: Option<HashAlgorithm>

The hashing algorithm

Implementations

impl EngineBuilder

pub fn new<T>(compiler_config: T) -> Self

where T: Into<Box<dyn CompilerConfig>>,

Create a new builder with pre-made components

pub fn headless() -> Self

Create a new headless Backend

pub fn set_target(self, target: Option<Target>) -> Self

Set the target

pub fn set_features(self, features: Option<Features>) -> Self

Set the features

pub fn set_hash_algorithm(self, hash_algorithm: Option<HashAlgorithm>) -> Self

Set the hashing algorithm

pub fn engine(self) -> Engine

Build the Engine for this configuration

pub fn features(&self) -> Option<&Features>

The Wasm features

pub fn target(&self) -> Option<&Target>

The target

Trait Implementations

impl From<EngineBuilder> for Engine

fn from(engine_builder: EngineBuilder) -> Self

Converts to this type from the input type.