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.

[View source]

85
86
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
 
# File 'ext/src/ruby_api/table.rs', line 85

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)
[View source]

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

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.

[View source]

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

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.

[View source]

142
143
144
 
# File 'ext/src/ruby_api/table.rs', line 142

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.

[View source]

136
137
138
 
# File 'ext/src/ruby_api/table.rs', line 136

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)
[View source]

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

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.

[View source]

210
211
212
 
# File 'ext/src/ruby_api/table.rs', line 210

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.

[View source]

130
131
132
 
# File 'ext/src/ruby_api/table.rs', line 130

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