use crate::externals::{Extern, Function, Global, Memory, Table};
use crate::import_object::LikeNamespace;
use crate::native::NativeFunc;
use crate::WasmTypeList;
use indexmap::IndexMap;
use std::fmt;
use std::iter::{ExactSizeIterator, FromIterator};
use std::sync::Arc;
use thiserror::Error;
use wasmer_engine::Export;
#[derive(Error, Debug)]
pub enum ExportError {
#[error("Incompatible Export Type")]
IncompatibleType,
#[error("Missing export {0}")]
Missing(String),
}
#[derive(Clone, Default)]
pub struct Exports {
map: Arc<IndexMap<String, Extern>>,
}
impl Exports {
pub fn new() -> Self {
Default::default()
}
pub fn with_capacity(n: usize) -> Self {
Self {
map: Arc::new(IndexMap::with_capacity(n)),
}
}
pub fn len(&self) -> usize {
self.map.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn insert<S, E>(&mut self, name: S, value: E)
where
S: Into<String>,
E: Into<Extern>,
{
Arc::get_mut(&mut self.map)
.unwrap()
.insert(name.into(), value.into());
}
pub fn get<'a, T: Exportable<'a>>(&'a self, name: &str) -> Result<&'a T, ExportError> {
match self.map.get(name) {
None => Err(ExportError::Missing(name.to_string())),
Some(extern_) => T::get_self_from_extern(extern_),
}
}
pub fn get_global(&self, name: &str) -> Result<&Global, ExportError> {
self.get(name)
}
pub fn get_memory(&self, name: &str) -> Result<&Memory, ExportError> {
self.get(name)
}
pub fn get_table(&self, name: &str) -> Result<&Table, ExportError> {
self.get(name)
}
pub fn get_function(&self, name: &str) -> Result<&Function, ExportError> {
self.get(name)
}
pub fn get_native_function<Args, Rets>(
&self,
name: &str,
) -> Result<NativeFunc<Args, Rets>, ExportError>
where
Args: WasmTypeList,
Rets: WasmTypeList,
{
self.get_function(name)?
.native()
.map_err(|_| ExportError::IncompatibleType)
}
pub fn get_with_generics<'a, T, Args, Rets>(&'a self, name: &str) -> Result<T, ExportError>
where
Args: WasmTypeList,
Rets: WasmTypeList,
T: ExportableWithGenerics<'a, Args, Rets>,
{
match self.map.get(name) {
None => Err(ExportError::Missing(name.to_string())),
Some(extern_) => T::get_self_from_extern_with_generics(extern_),
}
}
pub fn get_extern(&self, name: &str) -> Option<&Extern> {
self.map.get(name)
}
pub fn contains<S>(&self, name: S) -> bool
where
S: Into<String>,
{
self.map.contains_key(&name.into())
}
pub fn iter(&self) -> ExportsIterator<impl Iterator<Item = (&String, &Extern)>> {
ExportsIterator {
iter: self.map.iter(),
}
}
}
impl fmt::Debug for Exports {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_set().entries(self.iter()).finish()
}
}
pub struct ExportsIterator<'a, I>
where
I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
{
iter: I,
}
impl<'a, I> Iterator for ExportsIterator<'a, I>
where
I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
{
type Item = (&'a String, &'a Extern);
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
impl<'a, I> ExactSizeIterator for ExportsIterator<'a, I>
where
I: Iterator<Item = (&'a String, &'a Extern)> + ExactSizeIterator + Sized,
{
fn len(&self) -> usize {
self.iter.len()
}
}
impl<'a, I> ExportsIterator<'a, I>
where
I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
{
pub fn functions(self) -> impl Iterator<Item = (&'a String, &'a Function)> + Sized {
self.iter.filter_map(|(name, export)| match export {
Extern::Function(function) => Some((name, function)),
_ => None,
})
}
pub fn memories(self) -> impl Iterator<Item = (&'a String, &'a Memory)> + Sized {
self.iter.filter_map(|(name, export)| match export {
Extern::Memory(memory) => Some((name, memory)),
_ => None,
})
}
pub fn globals(self) -> impl Iterator<Item = (&'a String, &'a Global)> + Sized {
self.iter.filter_map(|(name, export)| match export {
Extern::Global(global) => Some((name, global)),
_ => None,
})
}
pub fn tables(self) -> impl Iterator<Item = (&'a String, &'a Table)> + Sized {
self.iter.filter_map(|(name, export)| match export {
Extern::Table(table) => Some((name, table)),
_ => None,
})
}
}
impl FromIterator<(String, Extern)> for Exports {
fn from_iter<I: IntoIterator<Item = (String, Extern)>>(iter: I) -> Self {
Self {
map: Arc::new(IndexMap::from_iter(iter)),
}
}
}
impl LikeNamespace for Exports {
fn get_namespace_export(&self, name: &str) -> Option<Export> {
self.map.get(name).map(|is_export| is_export.to_export())
}
fn get_namespace_exports(&self) -> Vec<(String, Export)> {
self.map
.iter()
.map(|(k, v)| (k.clone(), v.to_export()))
.collect()
}
}
pub trait Exportable<'a>: Sized {
fn to_export(&self) -> Export;
fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError>;
}
pub trait ExportableWithGenerics<'a, Args: WasmTypeList, Rets: WasmTypeList>: Sized {
fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError>;
}
impl<'a, T: Exportable<'a> + Clone + 'static> ExportableWithGenerics<'a, (), ()> for T {
fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError> {
T::get_self_from_extern(_extern).map(|i| i.clone())
}
}