Struct TypedArray 

pub struct TypedArray<T> { /* private fields */ }

Parameterised wrapper around a JavaScript array object. No concrete JS type, but needed for WebIDL

Implementations

impl<T> TypedArray<T>

pub fn new_from_slice(slice: &[T]) -> Self

where T: Clone + Into<Val>,

Construct a new JS array from a Rust slice. Uses a single array build operation instead of repeated push calls.

pub fn len(&self) -> usize

Number of elements (array.length).

pub fn is_empty(&self) -> bool

True when len() == 0.

pub fn push(&mut self, value: T)

where T: Into<Val>,

Push a single element to the end of the array.

pub fn get(&self, idx: usize) -> Option<T>

where T: FromVal,

Return a copy of the element at idx converted to T.

pub fn has(&self, val: T) -> bool

where Val: From<T>,

Returns whether a value exists in the TypedArray.

pub fn set(&self, idx: usize, val: T)

where T: FromVal, Val: From<T>,

pub fn to_vec(&self) -> Vec<T>

where T: FromVal,

Returns a Rust Vec from a TypedArray

pub fn to_string(&self) -> JsString

pub fn to_locale_string(&self) -> JsString

pub fn pop(&self) -> Option<T>

where T: FromVal,

pub fn concat(&self, items: &Self) -> Self

pub fn join(&self, separator: &JsString) -> JsString

pub fn reverse(&self) -> Self

pub fn shift(&self) -> Option<T>

where T: FromVal,

pub fn sort(&self, compare_fn: &Function) -> Self

pub fn splice(&self, start: usize, delete_count: usize, items: &Self) -> Self

pub fn unshift(&self, items: &Self) -> usize

pub fn index_of(&self, search_element: &Any, from_index: Option<usize>) -> isize

pub fn last_index_of( &self, search_element: &Any, from_index: Option<usize>, ) -> isize

pub fn every(&self, predicate: &Function, this_arg: Option<&Any>) -> bool

pub fn some(&self, predicate: &Function, this_arg: Option<&Any>) -> bool

pub fn for_each(&self, callbackfn: &Function, this_arg: Option<&Any>)

pub fn map( &self, callbackfn: &Function, this_arg: Option<&Any>, ) -> TypedArray<Any>

pub fn filter(&self, predicate: &Function, this_arg: Option<&Any>) -> Self

pub fn reduce(&self, callbackfn: &Function, initial_value: Option<&T>) -> T

where T: FromVal + Into<Val> + Clone + Default,

pub fn reduce_right( &self, callbackfn: &Function, initial_value: Option<&T>, ) -> T

where T: FromVal + Into<Val> + Clone + Default,

pub fn entries(&self) -> Any

pub fn keys(&self) -> Any

pub fn values(&self) -> Any

impl<T> TypedArray<T>

where T: FromVal,

pub fn iter(&self) -> TypedArrayIter<'_, T>

Return an iterator over owned elements.

Examples found in repository

examples/array.rs (line 12)

fn main() {
    emlite::init();
    // Create a TypedArray from a Vec of Any
    let seq = TypedArray::from(vec![Any::from(1), Any::from(2), Any::from(3)]);
    println!("Created TypedArray: {:?}", seq);

    // Access elements
    for (i, val) in seq.iter().enumerate() {
        println!("Element {}: {:?}", i, val);
    }

    // Convert TypedArray back to Vec<Any> (if supported by your API)
    // let vec: Vec<Any> = seq.clone().into();
    // println!("Converted back to Vec: {:?}", vec);
    // If not supported, just print the sequence
    println!("TypedArray: {:?}", seq);
}

Methods from Deref<Target = Val>

pub fn get<T>(&self, prop: T) -> Val

where T: Into<Val>,

Gets the property prop

pub fn set<K, V>(&self, prop: K, val: V)

where K: Into<Val>, V: Into<Val>,

Set the underlying js object property prop to val

pub fn has<T>(&self, prop: T) -> bool

where T: Into<Val>,

Checks whether a property prop exists

pub fn has_own_property(&self, prop: &str) -> bool

Checks whether a non-inherited property prop exists

pub fn type_of(&self) -> String

Gets the typeof the underlying js object

pub fn at<T>(&self, idx: T) -> Val

where T: Into<Val>,

Gets the element at index idx. Assumes the underlying js type is indexable

pub fn to_vec<V>(&self) -> Vec<V>

where V: FromVal,

Converts the underlying js array to a Vec of V

pub fn call(&self, f: &str, args: &[Val]) -> Val

Calls the method f with args, can return an undefined js value

pub fn new(&self, args: &[Val]) -> Val

Calls the object’s constructor with args constructing a new object

pub fn invoke(&self, args: &[Val]) -> Val

Invokes the function object with args, can return an undefined js value

pub fn await_(&self) -> Val

Awaits the invoked function object

pub fn instanceof(&self, v: Val) -> bool

Checks whether this Val is an instanceof v

pub fn is_number(&self) -> bool

pub fn is_bool(&self) -> bool

pub fn is_string(&self) -> bool

pub fn is_null(&self) -> bool

pub fn is_undefined(&self) -> bool

pub fn is_error(&self) -> bool

pub fn is_function(&self) -> bool

pub fn as_<T>(&self) -> T

where T: FromVal,

Examples found in repository

examples/any.rs (line 15)

fn main() {
    emlite::init();
    // Create Any from different Rust types
    let num = Any::from(123);
    let text = Any::from("hello");
    let boolean = Any::from(true);
    println!("Any from int: {:?}", num);
    println!("Any from str: {:?}", text);
    println!("Any from bool: {:?}", boolean);
    Console::get().log(&[num.clone(), text.clone(), boolean.clone()]);

    // Convert Any back to Rust types using as_::<T>()
    let n: i32 = num.as_();
    let s: Option<String> = text.as_();
    let b: bool = boolean.as_();
    println!("Extracted i32: {}", n);
    println!("Extracted String: {:?}", s);
    println!("Extracted bool: {}", b);
}

examples/closures.rs (line 10)

fn main() {
    emlite::init();

    // 0-arg closure returning a number
    let c0 = Closure::bind0(|| 42);
    let f0: Function = (&c0).into();
    let r0 = f0.call(&Any::undefined(), &[]).unwrap().as_::<i32>();
    Console::get().log(&[Any::from(r0)]);

    // 1-arg closure: add 1
    let c1 = Closure::bind1(|x: i32| x + 1);
    let f1: Function = (&c1).into();
    let r1 = f1
        .call(&Any::undefined(), &[Any::from(9)])
        .unwrap()
        .as_::<i32>();
    Console::get().log(&[Any::from(r1)]);

    // 2-arg closure: sum
    let c2 = Closure::bind2(|a: i32, b: i32| a + b);
    let f2: Function = (&c2).into();
    let r2 = f2
        .call(&Any::undefined(), &[Any::from(2), Any::from(3)])
        .unwrap()
        .as_::<i32>();
    Console::get().log(&[Any::from(r2)]);

    // 3-arg closure: format string
    let c3 = Closure::bind3(|a: i32, b: i32, c: i32| format!("{}-{}-{}", a, b, c));
    let f3: Function = (&c3).into();
    let r3 = f3
        .call(
            &Any::undefined(),
            &[Any::from(1), Any::from(2), Any::from(3)],
        )
        .unwrap()
        .as_::<Option<String>>()
        .unwrap();
    Console::get().log(&[Any::from(r3)]);

    // 4-arg closure: sum of four
    let c4 = Closure::bind4(|a: i32, b: i32, c: i32, d: i32| a + b + c + d);
    let f4: Function = (&c4).into();
    let r4 = f4
        .call(
            &Any::undefined(),
            &[Any::from(1), Any::from(2), Any::from(3), Any::from(4)],
        )
        .unwrap()
        .as_::<i32>();
    Console::get().log(&[Any::from(r4)]);
}

pub fn to_utf16(&self) -> Option<Vec<u16>>

Extracts UTF-16 data as Option<Vec>

pub fn to_utf16_result(&self) -> Result<Vec<u16>, Val>

Extracts UTF-16 data, returning error if null or if self is error

Trait Implementations

impl<T> AsMut<Val> for TypedArray<T>

fn as_mut(&mut self) -> &mut Val

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<Val> for TypedArray<T>

fn as_ref(&self) -> &Val

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for TypedArray<T>

fn clone(&self) -> TypedArray<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TypedArray<T>

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

Formats the value using the given formatter.

impl<T> Deref for TypedArray<T>

type Target = Val

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for TypedArray<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Clone> From<&[T]> for TypedArray<T>

where Val: From<T>,

fn from(slice: &[T]) -> Self

Converts to this type from the input type.

impl<T> From<&TypedArray<T>> for Val

fn from(x: &TypedArray<T>) -> Val

Converts to this type from the input type.

impl<T> From<TypedArray<T>> for Val

fn from(x: TypedArray<T>) -> Val

Converts to this type from the input type.

impl<T: Clone> From<Vec<T>> for TypedArray<T>

where Val: From<T>,

fn from(buf: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> FromVal for TypedArray<T>

fn from_val(v: &Val) -> Self

Creates a Val object from another

fn take_ownership(v: Handle) -> Self

Takes the ownership of a handle

fn as_handle(&self) -> Handle

Returns the raw js handle

impl<'a, T> IntoIterator for &'a TypedArray<T>

where T: FromVal,

type Item = T

The type of the elements being iterated over.

type IntoIter = TypedArrayIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for TypedArray<T>

fn eq(&self, other: &TypedArray<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for TypedArray<T>

fn partial_cmp(&self, other: &TypedArray<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> StructuralPartialEq for TypedArray<T>