Class: Wasmtime::Table

Inherits:
Object
  • Object
show all
Defined in:
ext/src/ruby_api/table.rs

Overview

Represents a WebAssembly table.

See Also:

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.new(store, type, initial, min_size:, max_size: nil) ⇒ Object

Parameters:

  • store (Store)
  • type (Symbol) —

    The WebAssembly type of the value held by this table.

  • initial (Value) —

    The initial value of values in the table.

  • min_size (Integer) —

    The minimum number of elements in the table.

  • max_size (Integer, nil) (defaults to: nil) —

    The maximum number of elements in the table.



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'ext/src/ruby_api/table.rs', line 87

pub fn new(args: &[Value]) -> Result<Self, Error> {
    let args = scan_args::scan_args::<(Obj<Store>, Symbol, Value), (), (), (), _, ()>(args)?;
    let kw = scan_args::get_kwargs::<_, (u32,), (Option<u32>,), ()>(
        args.keywords,
        &[*MIN_SIZE],
        &[*MAX_SIZE],
    )?;
    let (store, value_type, default) = args.required;
    let (min,) = kw.required;
    let (max,) = kw.optional;
    let wasm_type = value_type.to_val_type()?;
    let wasm_default = default.to_wasm_val(&store.into(), wasm_type.clone())?;
    let ref_ = wasm_default
        .ref_()
        .ok_or_else(|| error!("Expected Ref for table value"))?;

    let table_type = wasm_type
        .as_ref()
        .ok_or_else(|| error!("Expected RefType"))?
        .clone();

    let inner = TableImpl::new(
        store.context_mut(),
        wasmtime::TableType::new(table_type, min, max),
        ref_,
    )
    .map_err(|e| error!("{}", e))?;

    let table = Self {
        store: store.into(),
        inner,
    };

    table.retain_non_nil_extern_ref(default)?;

    Ok(table)
}

Instance Method Details

#get(index) ⇒ Object?

Returns the table element value at index, or nil if index is out of bound.

Parameters:

  • index (Integer)

Returns:

  • (Object, nil) 


154
155
156
157
158
159
 
# File 'ext/src/ruby_api/table.rs', line 154

pub fn get(&self, index: u64) -> Result<Value, Error> {
    match self.inner.get(self.store.context_mut()?, index) {
        Some(wasm_val) => Val::from(wasm_val).to_ruby_value(&self.store),
        None => Ok(().into_value()),
    }
}

#grow(delta, initial) ⇒ void

This method returns an undefined value.

Grows the size of this table by delta. Raises if the table grows beyond its limit.

Parameters:

  • delta (Integer) —

    The number of elements to add to the table.

  • initial (Object) —

    The initial value for newly added table slots.



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'ext/src/ruby_api/table.rs', line 193

pub fn grow(&self, delta: u64, initial: Value) -> Result<u64, Error> {
    self.inner
        .grow(
            self.store.context_mut()?,
            delta,
            initial
                .to_wasm_val(&self.store, wasmtime::ValType::from(self.value_type()?))?
                .ref_()
                .ok_or_else(|| error!("Expected Ref"))?,
        )
        .map_err(|e| error!("{}", e))
        .and_then(|result| {
            self.retain_non_nil_extern_ref(initial)?;
            Ok(result)
        })
}

#max_size ⇒ Integer?

Returns The maximum size of this table.

Returns:

  • (Integer, nil) —

    The maximum size of this table.



144
145
146
 
# File 'ext/src/ruby_api/table.rs', line 144

pub fn max_size(&self) -> Result<Option<u64>, Error> {
    self.ty().map(|ty| ty.maximum())
}

#min_size ⇒ Integer

Returns The minimum size of this table.

Returns:

  • (Integer) —

    The minimum size of this table.



138
139
140
 
# File 'ext/src/ruby_api/table.rs', line 138

pub fn min_size(&self) -> Result<u64, Error> {
    self.ty().map(|ty| ty.minimum())
}

#set(index, value) ⇒ void

This method returns an undefined value.

Sets the table entry at index to value.

Parameters:

  • index (Integer)
  • value (Object) 


168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'ext/src/ruby_api/table.rs', line 168

pub fn set(&self, index: u64, value: Value) -> Result<(), Error> {
    self.inner
        .set(
            self.store.context_mut()?,
            index,
            value
                .to_wasm_val(&self.store, wasmtime::ValType::from(self.value_type()?))?
                .ref_()
                .ok_or_else(|| error!("Expected Ref"))?,
        )
        .map_err(|e| error!("{}", e))
        .and_then(|result| {
            self.retain_non_nil_extern_ref(value)?;
            Ok(result)
        })
}

#size ⇒ Integer

Returns The size of the table.

Returns:

  • (Integer) —

    The size of the table.



212
213
214
 
# File 'ext/src/ruby_api/table.rs', line 212

pub fn size(&self) -> Result<u64, Error> {
    Ok(self.inner.size(self.store.context()?))
}

#type ⇒ Symbol

Returns The Wasm type of the elements of this table.

Returns:

  • (Symbol) —

    The Wasm type of the elements of this table.



132
133
134
 
# File 'ext/src/ruby_api/table.rs', line 132

pub fn type_(&self) -> Result<Symbol, Error> {
    self.ty()?.element().to_sym()
}