Struct JsArrayBuffer

pub struct JsArrayBuffer(/* private fields */);

The type of JavaScript ArrayBuffer objects.

Example

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

fn make_sequence(mut cx: FunctionContext) -> JsResult<JsArrayBuffer> {
    let len = cx.argument::<JsNumber>(0)?.value(&mut cx);
    let mut buffer = cx.array_buffer(len as usize)?;

    for (i, elem) in buffer.as_mut_slice(&mut cx).iter_mut().enumerate() {
        *elem = i as u8;
    }

    Ok(buffer)
}

Implementations

impl JsArrayBuffer

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

Constructs a new JsArrayBuffer object, safely zero-filled.

See also: Context::array_buffer

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

where C: Context<'cx>,

Constructs a JsArrayBuffer from a slice by copying its contents.

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

pub fn external<'a, C, T>(cx: &mut C, data: T) -> Handle<'a, Self>

where C: Context<'a>, T: AsMut<[u8]> + Send + 'static,

Available on crate feature external-buffers only.

Construct a new JsArrayBuffer from bytes allocated by Rust.

Compatibility Note

Some Node environments are built using V8’s sandboxed pointers functionality, which disallows the use of external buffers. In those environments, calling the underlying runtime function used by this method results in an immediate termination of the Node VM.

As a result, this API is disabled by default. If you are confident that your code will only be used in environments that disable sandboxed pointers, you can make use of this method by enabling the external-buffers feature flag.

pub fn region<'cx, T: Binary>( buffer: &Handle<'cx, JsArrayBuffer>, offset: usize, len: usize, ) -> Region<'cx, T>

Returns a region of this buffer.

See also: Handle<JsArrayBuffer>::region() for a more ergonomic form of this method.

Trait Implementations

impl Debug for JsArrayBuffer

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

Formats the value using the given formatter.

impl Object for JsArrayBuffer

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 TypedArray for JsArrayBuffer

type Item = u8

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, 'a, C>( &self, lock: &'a Lock<'_, C>, ) -> Result<Ref<'a, 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<'_, 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: &[u8]) -> JsResult<'cx, Self>

where C: Context<'cx>,

Constructs an instance from a slice by copying its contents.

impl Value for JsArrayBuffer

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.