fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-04-04 03:11:08 +00:00
Code Issues Projects Releases Wiki Activity

fixed value types in Atomics methods

Browse Source
This commit is contained in:
ibaryshnikov 2019-04-24 00:25:25 +08:00
parent 1071457c3d
commit f1eaefdf0d
1 changed files with 131 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
crates/js-sys/src/lib.rs
View File

@ -438,7 +438,6 @@ extern "C" {
pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer; pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer;
} }
// SharedArrayBuffer // SharedArrayBuffer
#[wasm_bindgen] #[wasm_bindgen]
extern "C" { extern "C" {
@ -504,132 +503,150 @@ extern "C" {
pub fn values(this: &Array) -> Iterator; pub fn values(this: &Array) -> Iterator;
} }
// Atomics /// The `Atomics` object provides atomic operations as static methods.
#[wasm_bindge] /// They are used with `SharedArrayBuffer` objects.
extern "C" { ///
#[derive(Clone, Debug)] /// The Atomic operations are installed on an `Atomics` module. Unlike
#[wasm_bindgen(extends = Object)] /// the other global objects, Atomics is not a constructor. You cannot
pub type Atomics; /// use it with a new operator or invoke the `Atomics` object as a
/// function. All properties and methods of `Atomics` are static
/// (as is the case with the Math object, for example).
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics)
#[allow(non_snake_case)]
pub mod Atomics {
use super::*;
/// The static `Atomics.add()` method adds a given value at a given #[wasm_bindgen]
/// position in the array and returns the old value at that position. extern "C" {
/// This atomic operation guarantees that no other write happens #[derive(Clone, Debug)]
/// until the modified value is written back. #[wasm_bindgen(extends = Object)]
/// pub type Atomics;
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add)
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn add(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>;
/// The static `Atomics.and()` method computes a bitwise AND with a given /// The static `Atomics.add()` method adds a given value at a given
/// value at a given position in the array, and returns the old value /// position in the array and returns the old value at that position.
/// at that position. /// This atomic operation guarantees that no other write happens
/// This atomic operation guarantees that no other write happens /// until the modified value is written back.
/// until the modified value is written back. ///
/// /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add)
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and) #[wasm_bindgen(static_method_of = Atomics, catch)]
#[wasm_bindgen(static_method_of = Atomics, catch)] pub fn add(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
pub fn and(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>;
/// The static `Atomics.compareExchange()` method exchanges a given /// The static `Atomics.and()` method computes a bitwise AND with a given
/// replacement value at a given position in the array, if a given expected /// value at a given position in the array, and returns the old value
/// value equals the old value. It returns the old value at that position /// at that position.
/// whether it was equal to the expected value or not. /// This atomic operation guarantees that no other write happens
/// This atomic operation guarantees that no other write happens /// until the modified value is written back.
/// until the modified value is written back. ///
/// /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and)
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange) #[wasm_bindgen(static_method_of = Atomics, catch)]
#[wasm_bindgen(static_method_of = Atomics, catch, js_name = compareExchange)] pub fn and(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
pub fn compare_exchange(
typed_array: &JsValue,
index: u32,
expected_value: &JsValue,
replacement_value: &JsValue,
) -> Result<JsValue, JsValue>;
/// The static `Atomics.exchange()` method stores a given value at a given /// The static `Atomics.compareExchange()` method exchanges a given
/// position in the array and returns the old value at that position. /// replacement value at a given position in the array, if a given expected
/// This atomic operation guarantees that no other write happens /// value equals the old value. It returns the old value at that position
/// until the modified value is written back. /// whether it was equal to the expected value or not.
/// /// This atomic operation guarantees that no other write happens
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange) /// until the modified value is written back.
#[wasm_bindgen(static_method_of = Atomics, catch)] ///
pub fn exchange(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>; /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange)
#[wasm_bindgen(static_method_of = Atomics, catch, js_name = compareExchange)]
pub fn compare_exchange(
typed_array: &JsValue,
index: u32,
expected_value: f32,
replacement_value: f32,
) -> Result<f32, JsValue>;
/// The static `Atomics.isLockFree()` method is used to determine /// The static `Atomics.exchange()` method stores a given value at a given
/// whether to use locks or atomic operations. It returns true, /// position in the array and returns the old value at that position.
/// if the given size is one of the `BYTES_PER_ELEMENT` property /// This atomic operation guarantees that no other write happens
/// of integer `TypedArray` types. /// until the modified value is written back.
/// ///
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree) /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange)
#[wasm_bindgen(static_method_of = Atomics, js_name = isLockFree)] #[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn is_lock_free(size: u32) -> bool; pub fn exchange(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
/// The static `Atomics.load()` method returns a value at a given /// The static `Atomics.isLockFree()` method is used to determine
/// position in the array. /// whether to use locks or atomic operations. It returns true,
/// /// if the given size is one of the `BYTES_PER_ELEMENT` property
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load) /// of integer `TypedArray` types.
#[wasm_bindgen(static_method_of = Atomics, catch)] ///
pub fn load(typed_array: &JsValue, index: u32) -> Result<JsValue, JsValue>; /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree)
#[wasm_bindgen(static_method_of = Atomics, js_name = isLockFree)]
pub fn is_lock_free(size: u32) -> bool;
/// The static `Atomics.notify()` method notifies up some agents that /// The static `Atomics.load()` method returns a value at a given
/// are sleeping in the wait queue. /// position in the array.
/// Note: This operation works with a shared `Int32Array` only. ///
/// /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load)
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify) #[wasm_bindgen(static_method_of = Atomics, catch)]
#[wasm_bindgen(static_method_of = Atomics, catch)] pub fn load(typed_array: &JsValue, index: u32) -> Result<f32, JsValue>;
pub fn notify(typed_array: &JsValue, index: u32, count: u32) -> Result<JsValue, JsValue>;
/// The static `Atomics.or()` method computes a bitwise OR with a given value /// The static `Atomics.notify()` method notifies up some agents that
/// at a given position in the array, and returns the old value at that position. /// are sleeping in the wait queue.
/// This atomic operation guarantees that no other write happens /// Note: This operation works with a shared `Int32Array` only.
/// until the modified value is written back. ///
/// /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify)
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or) #[wasm_bindgen(static_method_of = Atomics, catch)]
#[wasm_bindgen(static_method_of = Atomics, catch)] pub fn notify(typed_array: &JsValue, index: u32, count: u32) -> Result<u32, JsValue>;
pub fn or(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>;
/// The static `Atomics.store()` method stores a given value at the given /// The static `Atomics.or()` method computes a bitwise OR with a given value
/// position in the array and returns that value. /// at a given position in the array, and returns the old value at that position.
/// /// This atomic operation guarantees that no other write happens
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store) /// until the modified value is written back.
#[wasm_bindgen(static_method_of = Atomics, catch)] ///
pub fn store(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>; /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or)
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn or(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
/// The static `Atomics.sub()` method substracts a given value at a /// The static `Atomics.store()` method stores a given value at the given
/// given position in the array and returns the old value at that position. /// position in the array and returns that value.
/// This atomic operation guarantees that no other write happens ///
/// until the modified value is written back. /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store)
/// #[wasm_bindgen(static_method_of = Atomics, catch)]
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub) pub fn store(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn sub(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>;
/// The static `Atomics.wait()` method verifies that a given /// The static `Atomics.sub()` method substracts a given value at a
/// position in an `Int32Array` still contains a given value /// given position in the array and returns the old value at that position.
/// and if so sleeps, awaiting a wakeup or a timeout. /// This atomic operation guarantees that no other write happens
/// It returns a string which is either "ok", "not-equal", or "timed-out". /// until the modified value is written back.
/// Note: This operation only works with a shared `Int32Array` ///
/// and may not be allowed on the main thread. /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub)
/// #[wasm_bindgen(static_method_of = Atomics, catch)]
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait) pub fn sub(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn wait(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>;
/// Like `wait()`, but with timeout /// The static `Atomics.wait()` method verifies that a given
/// /// position in an `Int32Array` still contains a given value
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait) /// and if so sleeps, awaiting a wakeup or a timeout.
#[wasm_bindgen(static_method_of = Atomics, catch)] /// It returns a string which is either "ok", "not-equal", or "timed-out".
pub fn wait_with_timeout(typed_array: &JsValue, index: u32, value: JsValue, timeout: u32) -> Result<JsValue, JsValue>; /// Note: This operation only works with a shared `Int32Array`
/// and may not be allowed on the main thread.
///
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn wait(typed_array: &JsValue, index: u32, value: i32) -> Result<JsValue, JsValue>;
/// The static `Atomics.xor()` method computes a bitwise XOR /// Like `wait()`, but with timeout
/// with a given value at a given position in the array, ///
/// and returns the old value at that position. /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)
/// This atomic operation guarantees that no other write happens #[wasm_bindgen(static_method_of = Atomics, catch)]
/// until the modified value is written back. pub fn wait_with_timeout(
/// typed_array: &JsValue,
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor) index: u32,
#[wasm_bindgen(static_method_of = Atomics, catch)] value: i32,
pub fn xor(typed_array: &JsValue, index: u32, value: JsValue) -> Result<JsValue, JsValue>; timeout: f32,
) -> Result<JsValue, JsValue>;
/// The static `Atomics.xor()` method computes a bitwise XOR
/// with a given value at a given position in the array,
/// and returns the old value at that position.
/// This atomic operation guarantees that no other write happens
/// until the modified value is written back.
///
/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor)
#[wasm_bindgen(static_method_of = Atomics, catch)]
pub fn xor(typed_array: &JsValue, index: u32, value: f32) -> Result<f32, JsValue>;
}
} }
// Boolean // Boolean