Struct boa_engine::object::builtins::JsTypedArray

pub struct JsTypedArray { /* private fields */ }

JsTypedArray provides a wrapper for Boa’s implementation of the ECMAScript TypedArray builtin object.

Implementations

impl JsTypedArray

pub fn from_object(object: JsObject) -> JsResult<Self>

Create a JsTypedArray from a JsObject, if the object is not a typed array throw a TypeError.

This does not clone the fields of the typed array, it only does a shallow clone of the object.

pub fn length(&self, context: &mut Context) -> JsResult<usize>

Get the length of the array.

Same as array.length in JavaScript.

pub fn is_empty(&self, context: &mut Context) -> JsResult<bool>

Check if the array is empty, i.e. the length is zero.

pub fn at<T>(&self, index: T, context: &mut Context) -> JsResult<JsValue>

where T: Into<i64>,

Calls TypedArray.prototype.at().

pub fn buffer(&self, context: &mut Context) -> JsResult<JsValue>

Returns the ArrayBuffer referenced by this typed array at construction time.

Calls TypedArray.prototype.buffer().

Examples

let context = &mut Context::default();
let array_buffer8 = JsArrayBuffer::new(8, context)?;
let array = JsUint8Array::from_array_buffer(array_buffer8, context)?;
assert_eq!(
    array.buffer(context)?.as_object().unwrap().get(PropertyKey::String(js_string!("byteLength")), context).unwrap(),
    JsValue::new(8)
);

pub fn byte_length(&self, context: &mut Context) -> JsResult<usize>

Returns TypedArray.prototype.byteLength.

pub fn byte_offset(&self, context: &mut Context) -> JsResult<usize>

Returns TypedArray.prototype.byteOffset.

pub fn constructor(&self, context: &mut Context) -> JsResult<JsValue>

Function that created the instance object. It is the hidden TypedArray constructor function, but each typed array subclass also defines its own constructor property.

Returns TypedArray.prototype.constructor.

Examples

let context = &mut Context::default();
let array = JsUint8Array::from_iter(vec![1, 2, 3, 4, 5], context)?;
assert_eq!(
    Err(JsNativeError::typ()
        .with_message("the TypedArray constructor should never be called directly")
        .into()),
    array.constructor(context)
);

pub fn copy_within<T>( &self, target: T, start: u64, end: Option<u64>, context: &mut Context ) -> JsResult<Self>

where T: Into<JsValue>,

Shallow copies part of this typed array to another location in the same typed array and returns this typed array without modifying its length.

Returns TypedArray.prototype.copyWithin().

Examples

let context = &mut Context::default();
let array = JsUint8Array::from_iter(vec![1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8], context)?;
array.copy_within(3, 1, Some(3), context)?;
assert_eq!(array.get(0, context)?, JsValue::new(1.0));
assert_eq!(array.get(1, context)?, JsValue::new(2.0));
assert_eq!(array.get(2, context)?, JsValue::new(3.0));
assert_eq!(array.get(3, context)?, JsValue::new(2.0));
assert_eq!(array.get(4, context)?, JsValue::new(3.0));
assert_eq!(array.get(5, context)?, JsValue::new(6.0));
assert_eq!(array.get(6, context)?, JsValue::new(7.0));
assert_eq!(array.get(7, context)?, JsValue::new(8.0));

pub fn fill<T>( &self, value: T, start: Option<usize>, end: Option<usize>, context: &mut Context ) -> JsResult<Self>

where T: Into<JsValue>,

Calls TypedArray.prototype.fill().

pub fn every( &self, predicate: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<bool>

Calls TypedArray.prototype.every().

pub fn some( &self, callback: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<bool>

Calls TypedArray.prototype.some().

pub fn sort( &self, compare_fn: Option<JsFunction>, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.sort().

pub fn subarray( &self, begin: i64, end: i64, context: &mut Context ) -> JsResult<Self>

Returns a new typed array on the same ArrayBuffer store and with the same element types as for this typed array. The begin offset is inclusive and the end offset is exclusive.

Calls TypedArray.prototype.subarray().

Examples

let context = &mut Context::default();
let array = JsUint8Array::from_iter(vec![1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8], context)?;
let subarray2_6 = array.subarray(2, 6, context)?;
assert_eq!(subarray2_6.length(context)?, 4);
assert_eq!(subarray2_6.get(0, context)?, JsValue::new(3.0));
assert_eq!(subarray2_6.get(1, context)?, JsValue::new(4.0));
assert_eq!(subarray2_6.get(2, context)?, JsValue::new(5.0));
assert_eq!(subarray2_6.get(3, context)?, JsValue::new(6.0));
let subarray4_6 = array.subarray(-4, 6, context)?;
assert_eq!(subarray4_6.length(context)?, 2);
assert_eq!(subarray4_6.get(0, context)?, JsValue::new(5.0));
assert_eq!(subarray4_6.get(1, context)?, JsValue::new(6.0));

pub fn to_locale_string( &self, reserved1: Option<JsValue>, reserved2: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Calls TypedArray.prototype.toLocaleString()

pub fn filter( &self, callback: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.filter().

pub fn map( &self, callback: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.map().

pub fn reduce( &self, callback: JsFunction, initial_value: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Calls TypedArray.prototype.reduce().

pub fn reduce_right( &self, callback: JsFunction, initial_value: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Calls TypedArray.prototype.reduceRight().

pub fn reverse(&self, context: &mut Context) -> JsResult<Self>

Calls TypedArray.prototype.reverse().

pub fn set_values( &self, source: JsValue, offset: Option<u64>, context: &mut Context ) -> JsResult<JsValue>

Stores multiple values in the typed array, reading input values from a specified array.

Returns TypedArray.prototype.set().

Examples

let context = &mut Context::default();
let array_buffer8 = JsArrayBuffer::new(8, context)?;
let initialized8_array = JsUint8Array::from_array_buffer(array_buffer8, context)?;
initialized8_array.set_values(
  JsArray::from_iter(vec![JsValue::new(1), JsValue::new(2)], context).into(),
  Some(3),
  context,
)?;
assert_eq!(initialized8_array.get(0, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(1, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(2, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(3, context)?, JsValue::new(1.0));
assert_eq!(initialized8_array.get(4, context)?, JsValue::new(2.0));
assert_eq!(initialized8_array.get(5, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(6, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(7, context)?, JsValue::new(0));
assert_eq!(initialized8_array.get(8, context)?, JsValue::Undefined);

pub fn slice( &self, start: Option<usize>, end: Option<usize>, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.slice().

pub fn find( &self, predicate: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Calls TypedArray.prototype.find().

pub fn find_index( &self, predicate: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<Option<u64>>

Returns the index of the first element in an array that satisfies the provided testing function. If no elements satisfy the testing function, JsResult::Ok(None) is returned.

Calls TypedArray.prototype.findIndex().

Examples

let context = &mut Context::default();
let data: Vec<u8> = (0..=255).collect();
let array = JsUint8Array::from_iter(data, context)?;

let greter_than_10_predicate = FunctionObjectBuilder::new(
    context.realm(),
    NativeFunction::from_fn_ptr(|_this, args, _context| {
        let element = args
            .first()
            .cloned()
            .unwrap_or_default()
            .as_number()
            .expect("error at number conversion");
        Ok(JsValue::Boolean(element > 10.0))
    }),
)
.build();
assert_eq!(
    array.find_index(greter_than_10_predicate, None, context),
    Ok(Some(11))
);

pub fn find_last( &self, predicate: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Iterates the typed array in reverse order and returns the value of the first element that satisfies the provided testing function. If no elements satisfy the testing function, JsResult::Ok(None) is returned.

Calls TypedArray.prototype.findLast().

Examples

let context = &mut Context::default();
let data: Vec<u8> = (0..=255).collect();
let array = JsUint8Array::from_iter(data, context)?;

let lower_than_200_predicate = FunctionObjectBuilder::new(
    context.realm(),
    NativeFunction::from_fn_ptr(|_this, args, _context| {
        let element = args
            .first()
            .cloned()
            .unwrap_or_default()
            .as_number()
            .expect("error at number conversion");
        Ok(JsValue::Boolean(element < 200.0))
    }),
)
.build();
assert_eq!(
    array.find_last(lower_than_200_predicate.clone(), None, context),
    Ok(JsValue::Integer(199))
);

pub fn find_last_index( &self, predicate: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<Option<u64>>

Iterates the typed array in reverse order and returns the index of the first element that satisfies the provided testing function. If no elements satisfy the testing function, JsResult::OK(None) is returned.

Calls TypedArray.prototype.findLastIndex().

Examples

let context = &mut Context::default();
let data: Vec<u8> = (0..=255).collect();
let array = JsUint8Array::from_iter(data, context)?;

let lower_than_200_predicate = FunctionObjectBuilder::new(
    context.realm(),
    NativeFunction::from_fn_ptr(|_this, args, _context| {
        let element = args
            .first()
            .cloned()
            .unwrap_or_default()
            .as_number()
            .expect("error at number conversion");
        Ok(JsValue::Boolean(element < 200.0))
    }),
)
.build();
assert_eq!(
    array.find_last(lower_than_200_predicate.clone(), None, context),
    Ok(JsValue::Integer(199))
);

pub fn for_each( &self, callback: JsFunction, this_arg: Option<JsValue>, context: &mut Context ) -> JsResult<JsValue>

Executes a provided function once for each typed array element.

Calls TypedArray.prototype.forEach().

Examples

let context = &mut Context::default();
let array = JsUint8Array::from_iter(vec![1, 2, 3, 4, 5], context)?;
let num_to_modify = Gc::new(GcRefCell::new(0u8));

let js_function = FunctionObjectBuilder::new(
    context.realm(),
    NativeFunction::from_copy_closure_with_captures(
        |_, args, captures, inner_context| {
            let element = args
                .first()
                .cloned()
                .unwrap_or_default()
                .to_uint8(inner_context)
                .expect("error at number conversion");
            *captures.borrow_mut() += element;
            Ok(JsValue::Undefined)
        },
        Gc::clone(&num_to_modify),
    ),
)
.build();

array.for_each(js_function, None, context);
let borrow = *num_to_modify.borrow();
assert_eq!(borrow, 15u8);

pub fn includes<T>( &self, search_element: T, from_index: Option<u64>, context: &mut Context ) -> JsResult<bool>

where T: Into<JsValue>,

Determines whether a typed array includes a certain value among its entries, returning true or false as appropriate.

Calls TypedArray.prototype.includes().

Examples

let context = &mut Context::default();
let data: Vec<u8> = (0..=255).collect();
let array = JsUint8Array::from_iter(data, context)?;

assert_eq!(array.includes(JsValue::new(2), None, context), Ok(true));
let empty_array = JsUint8Array::from_iter(vec![], context)?;
assert_eq!(
    empty_array.includes(JsValue::new(2), None, context),
    Ok(false)
);

pub fn index_of<T>( &self, search_element: T, from_index: Option<usize>, context: &mut Context ) -> JsResult<Option<usize>>

where T: Into<JsValue>,

Calls TypedArray.prototype.indexOf().

pub fn last_index_of<T>( &self, search_element: T, from_index: Option<usize>, context: &mut Context ) -> JsResult<Option<usize>>

where T: Into<JsValue>,

Calls TypedArray.prototype.lastIndexOf().

pub fn join( &self, separator: Option<JsString>, context: &mut Context ) -> JsResult<JsString>

Calls TypedArray.prototype.join().

pub fn to_reversed(&self, context: &mut Context) -> JsResult<Self>

Calls TypedArray.prototype.toReversed ( ).

pub fn to_sorted( &self, compare_fn: Option<JsFunction>, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.toSorted ( comparefn ).

pub fn with( &self, index: u64, value: JsValue, context: &mut Context ) -> JsResult<Self>

Calls TypedArray.prototype.with ( index, value ).

pub fn to_string_tag(&self, context: &mut Context) -> JsResult<JsValue>

It is a getter that returns the same string as the typed array constructor’s name. It returns Ok(JsValue::Undefined) if the this value is not one of the typed array subclasses.

Returns TypedArray.prototype.toStringTag().

Examples

let context = &mut Context::default();
let array = JsUint8Array::from_iter(vec![1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8], context)?;
let tag = array.to_string_tag(context)?.to_string(context)?;
assert_eq!(tag, js_string!("Uint8Array"));

Methods from Deref<Target = JsObject>

pub fn downcast_ref<T: NativeObject>(&self) -> Option<Ref<'_, T>>

Downcasts a reference to the object, if the object is of type T.

Panics

Panics if the object is currently mutably borrowed.

pub fn downcast_mut<T: NativeObject>( &self ) -> Option<RefMut<'_, ErasedObject, T>>

Downcasts a mutable reference to the object, if the object is type native object type T.

Panics

Panics if the object is currently borrowed.

pub fn is<T: NativeObject>(&self) -> bool

Checks if this object is an instance of a certain NativeObject.

Panics

Panics if the object is currently mutably borrowed.

pub fn is_ordinary(&self) -> bool

Checks if it’s an ordinary object.

Panics

Panics if the object is currently mutably borrowed.

pub fn is_array(&self) -> bool

Checks if it’s an Array object.

pub fn to_property_descriptor( &self, context: &mut Context ) -> JsResult<PropertyDescriptor>

The abstract operation ToPropertyDescriptor.

More information:

• ECMAScript reference

pub fn copy_data_properties<K>( &self, source: &JsValue, excluded_keys: Vec<K>, context: &mut Context ) -> JsResult<()>

where K: Into<PropertyKey>,

7.3.25 CopyDataProperties ( target, source, excludedItems )

More information:

• ECMAScript

pub fn borrow(&self) -> Ref<'_, Object<T>>

Immutably borrows the Object.

The borrow lasts until the returned Ref exits scope. Multiple immutable borrows can be taken out at the same time.

Panics

Panics if the object is currently mutably borrowed.

pub fn borrow_mut(&self) -> RefMut<'_, Object<T>, Object<T>>

Mutably borrows the Object.

The borrow lasts until the returned RefMut exits scope. The object cannot be borrowed while this borrow is active.

Panics

Panics if the object is currently borrowed.

pub fn try_borrow(&self) -> StdResult<Ref<'_, Object<T>>, BorrowError>

Immutably borrows the Object, returning an error if the value is currently mutably borrowed.

The borrow lasts until the returned GcCellRef exits scope. Multiple immutable borrows can be taken out at the same time.

This is the non-panicking variant of borrow.

pub fn try_borrow_mut( &self ) -> StdResult<RefMut<'_, Object<T>, Object<T>>, BorrowMutError>

Mutably borrows the object, returning an error if the value is currently borrowed.

The borrow lasts until the returned GcCellRefMut exits scope. The object be borrowed while this borrow is active.

This is the non-panicking variant of borrow_mut.

pub fn prototype(&self) -> JsPrototype

Get the prototype of the object.

Panics

Panics if the object is currently mutably borrowed.

pub fn set_prototype(&self, prototype: JsPrototype) -> bool

Set the prototype of the object.

Panics

Panics if the object is currently mutably borrowed

pub fn insert_property<K, P>(&self, key: K, property: P) -> bool

where K: Into<PropertyKey>, P: Into<PropertyDescriptor>,

Inserts a field in the object properties without checking if it’s writable.

If a field was already in the object with the same name, than true is returned with that field, otherwise false is returned.

pub fn is_callable(&self) -> bool

It determines if Object is a callable function with a [[Call]] internal method.

More information:

• ECMAScript reference

pub fn is_constructor(&self) -> bool

It determines if Object is a function object with a [[Construct]] internal method.

More information:

• ECMAScript reference

pub fn is_extensible(&self, context: &mut Context) -> JsResult<bool>

Check if object is extensible.

More information:

• ECMAScript reference

pub fn get<K>(&self, key: K, context: &mut Context) -> JsResult<JsValue>

where K: Into<PropertyKey>,

Get property from object or throw.

More information:

• ECMAScript reference

pub fn set<K, V>( &self, key: K, value: V, throw: bool, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>, V: Into<JsValue>,

set property of object or throw if bool flag is passed.

More information:

• ECMAScript reference

pub fn create_data_property<K, V>( &self, key: K, value: V, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>, V: Into<JsValue>,

Create data property

More information:

• ECMAScript reference

pub fn create_data_property_or_throw<K, V>( &self, key: K, value: V, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>, V: Into<JsValue>,

Create data property or throw

More information:

• ECMAScript reference

pub fn define_property_or_throw<K, P>( &self, key: K, desc: P, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>, P: Into<PropertyDescriptor>,

Define property or throw.

More information:

• ECMAScript reference

pub fn delete_property_or_throw<K>( &self, key: K, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>,

Defines the property or throws a TypeError if the operation fails.

More information:

• ECMAScript reference

pub fn has_property<K>(&self, key: K, context: &mut Context) -> JsResult<bool>

where K: Into<PropertyKey>,

Check if object has property.

More information:

• ECMAScript reference

pub fn has_own_property<K>( &self, key: K, context: &mut Context ) -> JsResult<bool>

where K: Into<PropertyKey>,

Check if object has an own property.

More information:

• ECMAScript reference

pub fn call( &self, this: &JsValue, args: &[JsValue], context: &mut Context ) -> JsResult<JsValue>

Call ( F, V [ , argumentsList ] )

Panics

Panics if the object is currently mutably borrowed.

More information:

• ECMAScript reference

pub fn construct( &self, args: &[JsValue], new_target: Option<&Self>, context: &mut Context ) -> JsResult<Self>

Construct ( F [ , argumentsList [ , newTarget ] ] )

Construct an instance of this object with the specified arguments.

Panics

Panics if the object is currently mutably borrowed.

More information:

• ECMAScript reference

pub fn set_integrity_level( &self, level: IntegrityLevel, context: &mut Context ) -> JsResult<bool>

Make the object sealed or frozen.

More information:

• ECMAScript reference

pub fn test_integrity_level( &self, level: IntegrityLevel, context: &mut Context ) -> JsResult<bool>

Check if the object is sealed or frozen.

More information:

• ECMAScript reference

Trait Implementations

impl Clone for JsTypedArray

fn clone(&self) -> JsTypedArray

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsTypedArray

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

Formats the value using the given formatter.

impl Deref for JsTypedArray

type Target = JsObject

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for JsTypedArray

fn drop(&mut self)

Executes the destructor for this type.

impl Finalize for JsTypedArray

fn finalize(&self)

Cleanup logic for a type.

impl From<JsTypedArray> for JsObject

fn from(o: JsTypedArray) -> Self

Converts to this type from the input type.

impl From<JsTypedArray> for JsValue

fn from(o: JsTypedArray) -> Self

Converts to this type from the input type.

impl Trace for JsTypedArray

unsafe fn trace(&self, tracer: &mut Tracer)

Marks all contained Gcs.

unsafe fn trace_non_roots(&self)

Trace handles located in GC heap, and mark them as non root.

fn run_finalizer(&self)

Runs Finalize::finalize on this object and all contained subobjects.

impl TryFromJs for JsTypedArray

fn try_from_js(value: &JsValue, _context: &mut Context) -> JsResult<Self>

This function tries to convert a JavaScript value into Self.