From 1071457c3d2ce0711c48e347244f3d54341806bb Mon Sep 17 00:00:00 2001 From: ibaryshnikov Date: Tue, 16 Apr 2019 06:35:52 +0900 Subject: [PATCH] added SharedArrayBuffer and Atomics to js-sys --- crates/js-sys/src/lib.rs | 169 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) diff --git a/crates/js-sys/src/lib.rs b/crates/js-sys/src/lib.rs index 7593aa0f8..d5ec0b39e 100644 --- a/crates/js-sys/src/lib.rs +++ b/crates/js-sys/src/lib.rs @@ -438,6 +438,47 @@ extern "C" { pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer; } + +// SharedArrayBuffer +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(extends = Object)] + #[derive(Clone, Debug)] + pub type SharedArrayBuffer; + + /// The `SharedArrayBuffer` object is used to represent a generic, + /// fixed-length raw binary data buffer, similar to the `ArrayBuffer` + /// object, but in a way that they can be used to create views + /// on shared memory. Unlike an `ArrayBuffer`, a `SharedArrayBuffer` + /// cannot become detached. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) + #[wasm_bindgen(constructor)] + pub fn new(length: u32) -> SharedArrayBuffer; + + /// The byteLength accessor property represents the length of + /// an `SharedArrayBuffer` in bytes. This is established when + /// the `SharedArrayBuffer` is constructed and cannot be changed. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/byteLength) + #[wasm_bindgen(method, getter, js_name = byteLength)] + pub fn byte_length(this: &SharedArrayBuffer) -> u32; + + /// The `slice()` method returns a new `SharedArrayBuffer` whose contents + /// are a copy of this `SharedArrayBuffer`'s bytes from begin, inclusive, + /// up to end, exclusive. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice) + #[wasm_bindgen(method)] + pub fn slice(this: &SharedArrayBuffer, begin: u32) -> SharedArrayBuffer; + + /// Like `slice()` but with the `end` argument. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice) + #[wasm_bindgen(method, js_name = slice)] + pub fn slice_with_end(this: &SharedArrayBuffer, begin: u32, end: u32) -> SharedArrayBuffer; +} + // Array Iterator #[wasm_bindgen] extern "C" { @@ -463,6 +504,134 @@ extern "C" { pub fn values(this: &Array) -> Iterator; } +// Atomics +#[wasm_bindge] +extern "C" { + #[derive(Clone, Debug)] + #[wasm_bindgen(extends = Object)] + pub type Atomics; + + /// The static `Atomics.add()` method adds 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/add) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn add(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.and()` method computes a bitwise AND 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/and) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn and(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.compareExchange()` method exchanges a given + /// replacement value at a given position in the array, if a given expected + /// value equals the old value. It returns the old value at that position + /// whether it was equal to the expected value or not. + /// 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/compareExchange) + #[wasm_bindgen(static_method_of = Atomics, catch, js_name = compareExchange)] + pub fn compare_exchange( + typed_array: &JsValue, + index: u32, + expected_value: &JsValue, + replacement_value: &JsValue, + ) -> Result; + + /// The static `Atomics.exchange()` method stores 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/exchange) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn exchange(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.isLockFree()` method is used to determine + /// whether to use locks or atomic operations. It returns true, + /// if the given size is one of the `BYTES_PER_ELEMENT` property + /// of integer `TypedArray` types. + /// + /// [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.load()` method returns a value at a given + /// position in the array. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn load(typed_array: &JsValue, index: u32) -> Result; + + /// The static `Atomics.notify()` method notifies up some agents that + /// are sleeping in the wait queue. + /// Note: This operation works with a shared `Int32Array` only. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn notify(typed_array: &JsValue, index: u32, count: u32) -> Result; + + /// The static `Atomics.or()` method computes a bitwise OR 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/or) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn or(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.store()` method stores a given value at the given + /// position in the array and returns that value. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn store(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.sub()` method substracts 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/sub) + #[wasm_bindgen(static_method_of = Atomics, catch)] + pub fn sub(typed_array: &JsValue, index: u32, value: JsValue) -> Result; + + /// The static `Atomics.wait()` method verifies that a given + /// position in an `Int32Array` still contains a given value + /// and if so sleeps, awaiting a wakeup or a timeout. + /// It returns a string which is either "ok", "not-equal", or "timed-out". + /// 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: JsValue) -> Result; + + /// Like `wait()`, but with timeout + /// + /// [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_with_timeout(typed_array: &JsValue, index: u32, value: JsValue, timeout: u32) -> Result; + + /// 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: JsValue) -> Result; +} + // Boolean #[wasm_bindgen] extern "C" {