Type Alias JsInt32Array

pub type JsInt32Array = JsTypedArray<i32>;

The type of JavaScript Int32Array objects.

Example

use neon::types::buffer::TypedArray;

fn double(mut cx: FunctionContext) -> JsResult<JsUndefined> {
    let mut array: Handle<JsInt32Array> = cx.argument(0)?;

    for elem in array.as_mut_slice(&mut cx).iter_mut() {
        *elem *= 2;
    }

    Ok(cx.undefined())
}

Aliased Type

struct JsInt32Array(/* private fields */);

Implementations

impl<T: Binary> JsTypedArray<T>

where JsTypedArray<T>: Value,

pub fn from_slice<'cx, C>(cx: &mut C, slice: &[T]) -> JsResult<'cx, Self>

where C: Context<'cx>,

Constructs an instance from a slice by copying its contents.

This method is defined on JsTypedArray as a convenience and delegates to TypedArray::from_slice.

impl<T> JsTypedArray<T>

where T: Binary, Self: Value,

pub fn from_buffer<'cx, 'b: 'cx, C>( cx: &mut C, buffer: Handle<'b, JsArrayBuffer>, ) -> JsResult<'cx, Self>

where C: Context<'cx>,

Constructs a typed array that views buffer.

The resulting typed array has (buffer.size() / size_of::<T>()) elements.

pub fn from_region<'c, 'r, C>( cx: &mut C, region: &Region<'r, T>, ) -> JsResult<'c, Self>

where C: Context<'c>,

Constructs a typed array for the specified buffer region.

The resulting typed array has region.len() elements and a size of region.size() bytes.

Throws an exception if the region is invalid, for example if the starting offset is not properly aligned, or the length goes beyond the end of the buffer.

pub fn region<'cx, C>(&self, cx: &mut C) -> Region<'cx, T>

where C: Context<'cx>,

Returns information about the backing buffer region for this typed array.

pub fn new<'cx, C>(cx: &mut C, len: usize) -> JsResult<'cx, Self>

where C: Context<'cx>,

Constructs a new typed array of length len.

The resulting typed array has a newly allocated storage buffer of size (len * size_of::<T>()) bytes.

pub fn buffer<'cx, C>(&self, cx: &mut C) -> Handle<'cx, JsArrayBuffer>

where C: Context<'cx>,

Returns the JsArrayBuffer that owns the underlying storage buffer for this typed array.

Note that the typed array might only reference a region of the buffer; use the offset() and size() methods to determine the region.

pub fn offset<'cx, C>(&self, cx: &mut C) -> usize

where C: Context<'cx>,

Returns the offset (in bytes) of the typed array from the start of its JsArrayBuffer.

pub fn len<'cx, C>(&self, cx: &mut C) -> usize

where C: Context<'cx>,

Returns the length of the typed array, i.e. the number of elements.

Note that, depending on the element size, this is not necessarily the same as size(). In particular:

self.size() == self.len() * size_of::<T>()

Trait Implementations

impl<T: Debug + Binary> Debug for JsTypedArray<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Object for JsTypedArray<i32>

fn prop<'a, 'cx: 'a, K: PropertyKey>( &self, cx: &'a mut Cx<'cx>, key: K, ) -> PropOptions<'a, 'cx, Self, K>

Create a PropOptions for accessing a property.

fn method<'a, 'cx: 'a, K: PropertyKey>( &self, cx: &'a mut Cx<'cx>, key: K, ) -> NeonResult<BindOptions<'a, 'cx>>

Gets a property from the object as a method and binds this to the object.

fn get_opt<'a, V: Value, C: Context<'a>, K: PropertyKey>( &self, cx: &mut C, key: K, ) -> NeonResult<Option<Handle<'a, V>>>

👎Deprecating in a future version: use Object::prop() instead

fn get_value<'a, C: Context<'a>, K: PropertyKey>( &self, cx: &mut C, key: K, ) -> NeonResult<Handle<'a, JsValue>>

👎Deprecating in a future version: use Object::prop() instead

fn get<'a, V: Value, C: Context<'a>, K: PropertyKey>( &self, cx: &mut C, key: K, ) -> NeonResult<Handle<'a, V>>

👎Deprecating in a future version: use Object::prop() instead

fn get_own_property_names<'a, C: Context<'a>>( &self, cx: &mut C, ) -> JsResult<'a, JsArray>

Available on crate feature napi-6 only.

fn freeze<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self>

fn seal<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self>

fn set<'a, C: Context<'a>, K: PropertyKey, W: Value>( &self, cx: &mut C, key: K, val: Handle<'_, W>, ) -> NeonResult<bool>

👎Deprecating in a future version: use Object::prop() instead

fn root<'a, C: Context<'a>>(&self, cx: &mut C) -> Root<Self>

fn call_method_with<'a, C, K>( &self, cx: &mut C, method: K, ) -> NeonResult<CallOptions<'a>>

where C: Context<'a>, K: PropertyKey,

👎Deprecating in a future version: use Object::method() instead

impl<T> TypedArray for JsTypedArray<T>

where T: Binary, Self: Value,

type Item = T

fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]

where C: Context<'cx>,

Statically checked immutable borrow of binary data.

fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::Item]

where C: Context<'cx>,

Statically checked mutable borrow of binary data.

fn try_borrow<'cx, 'b, C>( &self, lock: &'b Lock<'b, C>, ) -> Result<Ref<'b, Self::Item>, BorrowError>

where C: Context<'cx>,

Dynamically checked immutable borrow of binary data, returning an error if the the borrow would overlap with a mutable borrow.

fn try_borrow_mut<'cx, 'a, C>( &mut self, lock: &'a Lock<'a, C>, ) -> Result<RefMut<'a, Self::Item>, BorrowError>

where C: Context<'cx>,

Dynamically checked mutable borrow of binary data, returning an error if the the borrow would overlap with an active borrow.

fn size<'cx, C: Context<'cx>>(&self, cx: &mut C) -> usize

Returns the size, in bytes, of the allocated binary data.

fn from_slice<'cx, C>(cx: &mut C, slice: &[T]) -> JsResult<'cx, Self>

where C: Context<'cx>,

Constructs an instance from a slice by copying its contents.

impl Value for JsTypedArray<i32>

fn to_string<'cx, C: Context<'cx>>(&self, cx: &mut C) -> JsResult<'cx, JsString>

fn as_value<'cx, C: Context<'cx>>(&self, _: &mut C) -> Handle<'cx, JsValue>

fn to_raw(&self) -> Value

Available on crate feature sys only.

Get a raw reference to the wrapped Node-API value.

unsafe fn from_raw<'cx, C: Context<'cx>>( cx: &C, value: Value, ) -> Handle<'cx, Self>

Available on crate feature sys only.

Creates a value from a raw Node-API value.