Skip to main content

dnet_js/transferable/
typed_array.rs

1//! Implementation of [IntoTransferable] and [FromTransferable] for
2//! JavaScript [typed arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
3
4use std::marker::PhantomData;
5
6use dnet_base::{Codec, Decode, Encode};
7use js_sys::{
8    Array, ArrayBuffer, BigInt64Array, BigUint64Array, Float16Array, Float32Array, Float64Array,
9    Int16Array, Int32Array, Int8Array, Uint16Array, Uint32Array, Uint8Array,
10};
11use js_utils::JsError;
12use wasm_bindgen::{JsCast, JsValue};
13
14use crate::{
15    wrapper::{self, Context},
16    FromTransferable, IntoTransferable, Transferable, WithTransferable,
17};
18
19/// Helper trait implemented here by [typed arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
20pub trait TypedArray: JsCast {
21    /// Get TypedArray's [ArrayBuffer] (using its `buffer()` method`).
22    fn array_buffer(&self) -> ArrayBuffer;
23}
24
25/// Wrapper over [typed arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
26///
27/// Used to implement [IntoTransferable]/[FromTransferable] with [wrapper::Context] for the use
28/// in structs/enums using [derive@IntoTransferable] derive.
29pub struct Wrapper<Codec, T>
30where
31    T: TypedArray,
32{
33    /// Wrapped [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
34    pub typed_array: T,
35
36    _codec: PhantomData<Codec>,
37}
38
39impl<C, T> Transferable for Wrapper<C, T>
40where
41    C: Codec,
42    T: TypedArray,
43{
44    type Context = Context<C>;
45
46    type Error = wrapper::Error<<C as Encode>::Error, <C as Decode>::Error>;
47
48    fn prepare_for_transfer(
49        self,
50        _context: &mut Self::Context,
51    ) -> Result<WithTransferable, Self::Error> {
52        let transfer = Array::of1(&self.typed_array.array_buffer());
53        Ok(WithTransferable {
54            data: self.typed_array.into(),
55            transfer,
56        })
57    }
58
59    fn reconstruct(object: JsValue, _context: &mut Self::Context) -> Result<Self, Self::Error>
60    where
61        Self: Sized,
62    {
63        Ok(Wrapper {
64            typed_array: object.dyn_into().map_err(|_| wrapper::Error::WrongType)?,
65            _codec: PhantomData,
66        })
67    }
68}
69
70macro_rules! impl_transferable_for_typed_array {
71    ($ty:ty) => {
72        impl IntoTransferable<(), JsError> for $ty {
73            type Output = Self;
74
75            fn into_transferable(self) -> Self::Output {
76                self
77            }
78        }
79
80        impl FromTransferable<(), JsError> for $ty {
81            type Input = Self;
82
83            fn from_transferable(input: Self::Input) -> Self {
84                input
85            }
86        }
87
88        impl Transferable for $ty {
89            type Context = ();
90
91            type Error = JsError;
92
93            fn prepare_for_transfer(
94                self,
95                _context: &mut Self::Context,
96            ) -> Result<WithTransferable, Self::Error> {
97                let transfer = Array::of1(&self.buffer());
98                Ok(WithTransferable {
99                    data: self.into(),
100                    transfer,
101                })
102            }
103
104            fn reconstruct(
105                object: JsValue,
106                _context: &mut Self::Context,
107            ) -> Result<Self, Self::Error>
108            where
109                Self: Sized,
110            {
111                object.dyn_into().map_err(JsError::from)
112            }
113        }
114
115        impl<C>
116            IntoTransferable<Context<C>, wrapper::Error<<C as Encode>::Error, <C as Decode>::Error>>
117            for $ty
118        where
119            C: Codec,
120        {
121            type Output = Wrapper<C, Self>;
122
123            fn into_transferable(self) -> Self::Output {
124                Wrapper {
125                    typed_array: self,
126                    _codec: PhantomData,
127                }
128            }
129        }
130
131        impl<C>
132            FromTransferable<Context<C>, wrapper::Error<<C as Encode>::Error, <C as Decode>::Error>>
133            for $ty
134        where
135            C: Codec,
136        {
137            type Input = Wrapper<C, Self>;
138
139            fn from_transferable(input: Self::Input) -> Self {
140                input.typed_array
141            }
142        }
143
144        impl TypedArray for $ty {
145            fn array_buffer(&self) -> ArrayBuffer {
146                self.buffer()
147            }
148        }
149    };
150}
151
152impl_transferable_for_typed_array!(Int8Array);
153impl_transferable_for_typed_array!(Uint8Array);
154impl_transferable_for_typed_array!(Int16Array);
155impl_transferable_for_typed_array!(Uint16Array);
156impl_transferable_for_typed_array!(Int32Array);
157impl_transferable_for_typed_array!(Uint32Array);
158impl_transferable_for_typed_array!(Float16Array);
159impl_transferable_for_typed_array!(Float32Array);
160impl_transferable_for_typed_array!(Float64Array);
161impl_transferable_for_typed_array!(BigInt64Array);
162impl_transferable_for_typed_array!(BigUint64Array);
163
164#[cfg(test)]
165mod tests {
166    use std::rc::Rc;
167
168    use dnet_base::Receive;
169    use dnet_codecs::{bincode, BincodeCodec};
170    use dnet_macros::IntoTransferable;
171    use dnet_tests::dtest_configure;
172    use futures::{join, SinkExt};
173    use js_sys::{
174        BigInt64Array, BigUint64Array, Float16Array, Float32Array, Float64Array, Int16Array,
175        Int32Array, Int8Array, Uint16Array, Uint32Array, Uint8Array,
176    };
177    use js_utils::JsError;
178    use wasm_bindgen_test::wasm_bindgen_test;
179    use web_sys::{MessageChannel, MessagePort};
180
181    use crate::{wrapper, TransferableTransport};
182
183    dtest_configure!();
184
185    async fn create_transports_simple<I, O>() -> (
186        TransferableTransport<MessagePort, (), I, O, JsError>,
187        TransferableTransport<MessagePort, (), O, I, JsError>,
188    )
189    where
190        I: crate::FromTransferable<(), JsError> + crate::IntoTransferable<(), JsError>,
191        O: crate::FromTransferable<(), JsError> + crate::IntoTransferable<(), JsError>,
192    {
193        let channel = MessageChannel::new().unwrap();
194
195        let left_port = Rc::new(channel.port1());
196        let right_port = Rc::new(channel.port2());
197
198        let left = TransferableTransport::new(&left_port, None, (), true);
199        let right = TransferableTransport::new(&right_port, None, (), true);
200
201        left_port.start();
202        right_port.start();
203
204        let (left, right) = join!(left, right);
205        let left = left.unwrap();
206        let right = right.unwrap();
207
208        (left, right)
209    }
210
211    type Context = wrapper::Context<BincodeCodec>;
212    type Error = wrapper::Error<bincode::EncodeError, bincode::DecodeError>;
213
214    async fn create_transports<I, O>() -> (
215        TransferableTransport<MessagePort, Context, I, O, Error>,
216        TransferableTransport<MessagePort, Context, O, I, Error>,
217    )
218    where
219        I: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
220        O: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
221    {
222        let channel = MessageChannel::new().unwrap();
223
224        let left_port = Rc::new(channel.port1());
225        let right_port = Rc::new(channel.port2());
226
227        let left = TransferableTransport::new(
228            &left_port,
229            None,
230            Context::new(BincodeCodec::default()),
231            true,
232        );
233        let right = TransferableTransport::new(
234            &right_port,
235            None,
236            Context::new(BincodeCodec::default()),
237            true,
238        );
239
240        left_port.start();
241        right_port.start();
242
243        let (left, right) = join!(left, right);
244        let left = left.unwrap();
245        let right = right.unwrap();
246
247        (left, right)
248    }
249
250    #[wasm_bindgen_test]
251    async fn test_int8_array_into_transferable() {
252        let (mut left, mut right) = create_transports_simple::<Int8Array, Int8Array>().await;
253
254        dnet_tests::init_logging(&mut left, &mut right);
255
256        let array = Int8Array::new_with_length(3);
257        array.copy_from(&[1, 2, 3]);
258
259        left.send(array).await.unwrap();
260
261        let received = right.receive().await.unwrap();
262
263        assert_eq!(received.length(), 3);
264        assert_eq!(received.to_vec(), vec![1, 2, 3]);
265    }
266
267    #[wasm_bindgen_test]
268    async fn test_int8_array_into_transferable_in_derive() {
269        #[derive(Debug, IntoTransferable)]
270        struct Message {
271            #[into_transferable]
272            array: Int8Array,
273        }
274
275        #[derive(Debug, IntoTransferable)]
276        struct Empty {}
277
278        let (mut left, mut right) = create_transports::<Empty, Message>().await;
279
280        dnet_tests::init_logging(&mut left, &mut right);
281
282        let array = Int8Array::new_with_length(3);
283        array.copy_from(&[1, 2, 3]);
284
285        let message = Message { array };
286        left.send(message).await.unwrap();
287
288        let received = right.receive().await.unwrap();
289
290        assert_eq!(received.array.length(), 3);
291        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
292    }
293
294    #[wasm_bindgen_test]
295    async fn test_uint8_array_into_transferable() {
296        let (mut left, mut right) = create_transports_simple::<Uint8Array, Uint8Array>().await;
297
298        dnet_tests::init_logging(&mut left, &mut right);
299
300        let array = Uint8Array::new_with_length(3);
301        array.copy_from(&[1, 2, 3]);
302
303        left.send(array).await.unwrap();
304
305        let received = right.receive().await.unwrap();
306
307        assert_eq!(received.length(), 3);
308        assert_eq!(received.to_vec(), vec![1, 2, 3]);
309    }
310
311    #[wasm_bindgen_test]
312    async fn test_uint8_array_into_transferable_in_derive() {
313        #[derive(Debug, IntoTransferable)]
314        struct Message {
315            #[into_transferable]
316            array: Uint8Array,
317        }
318
319        #[derive(Debug, IntoTransferable)]
320        struct Empty {}
321
322        let (mut left, mut right) = create_transports::<Empty, Message>().await;
323
324        dnet_tests::init_logging(&mut left, &mut right);
325
326        let array = Uint8Array::new_with_length(3);
327        array.copy_from(&[1, 2, 3]);
328
329        let message = Message { array };
330        left.send(message).await.unwrap();
331
332        let received = right.receive().await.unwrap();
333
334        assert_eq!(received.array.length(), 3);
335        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
336    }
337
338    #[wasm_bindgen_test]
339    async fn test_int16_array_into_transferable() {
340        let (mut left, mut right) = create_transports_simple::<Int16Array, Int16Array>().await;
341
342        dnet_tests::init_logging(&mut left, &mut right);
343
344        let array = Int16Array::new_with_length(3);
345        array.copy_from(&[1, 2, 3]);
346
347        left.send(array).await.unwrap();
348
349        let received = right.receive().await.unwrap();
350
351        assert_eq!(received.length(), 3);
352        assert_eq!(received.to_vec(), vec![1, 2, 3]);
353    }
354
355    #[wasm_bindgen_test]
356    async fn test_int16_array_into_transferable_in_derive() {
357        #[derive(Debug, IntoTransferable)]
358        struct Message {
359            #[into_transferable]
360            array: Int16Array,
361        }
362
363        #[derive(Debug, IntoTransferable)]
364        struct Empty {}
365
366        let (mut left, mut right) = create_transports::<Empty, Message>().await;
367
368        dnet_tests::init_logging(&mut left, &mut right);
369
370        let array = Int16Array::new_with_length(3);
371        array.copy_from(&[1, 2, 3]);
372
373        let message = Message { array };
374        left.send(message).await.unwrap();
375
376        let received = right.receive().await.unwrap();
377
378        assert_eq!(received.array.length(), 3);
379        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
380    }
381
382    #[wasm_bindgen_test]
383    async fn test_uint16_array_into_transferable() {
384        let (mut left, mut right) = create_transports_simple::<Uint16Array, Uint16Array>().await;
385
386        dnet_tests::init_logging(&mut left, &mut right);
387
388        let array = Uint16Array::new_with_length(3);
389        array.copy_from(&[1, 2, 3]);
390
391        left.send(array).await.unwrap();
392
393        let received = right.receive().await.unwrap();
394
395        assert_eq!(received.length(), 3);
396        assert_eq!(received.to_vec(), vec![1, 2, 3]);
397    }
398
399    #[wasm_bindgen_test]
400    async fn test_uint16_array_into_transferable_in_derive() {
401        #[derive(Debug, IntoTransferable)]
402        struct Message {
403            #[into_transferable]
404            array: Uint16Array,
405        }
406
407        #[derive(Debug, IntoTransferable)]
408        struct Empty {}
409
410        let (mut left, mut right) = create_transports::<Empty, Message>().await;
411
412        dnet_tests::init_logging(&mut left, &mut right);
413
414        let array = Uint16Array::new_with_length(3);
415        array.copy_from(&[1, 2, 3]);
416
417        let message = Message { array };
418        left.send(message).await.unwrap();
419
420        let received = right.receive().await.unwrap();
421
422        assert_eq!(received.array.length(), 3);
423        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
424    }
425
426    #[wasm_bindgen_test]
427    async fn test_uint32_array_into_transferable() {
428        let (mut left, mut right) = create_transports_simple::<Uint32Array, Uint32Array>().await;
429
430        dnet_tests::init_logging(&mut left, &mut right);
431
432        let array = Uint32Array::new_with_length(3);
433        array.copy_from(&[1, 2, 3]);
434
435        left.send(array).await.unwrap();
436
437        let received = right.receive().await.unwrap();
438
439        assert_eq!(received.length(), 3);
440        assert_eq!(received.to_vec(), vec![1, 2, 3]);
441    }
442
443    #[wasm_bindgen_test]
444    async fn test_uint32_array_into_transferable_in_derive() {
445        #[derive(Debug, IntoTransferable)]
446        struct Message {
447            #[into_transferable]
448            array: Uint32Array,
449        }
450
451        #[derive(Debug, IntoTransferable)]
452        struct Empty {}
453
454        let (mut left, mut right) = create_transports::<Empty, Message>().await;
455
456        dnet_tests::init_logging(&mut left, &mut right);
457
458        let array = Uint32Array::new_with_length(3);
459        array.copy_from(&[1, 2, 3]);
460
461        let message = Message { array };
462        left.send(message).await.unwrap();
463
464        let received = right.receive().await.unwrap();
465
466        assert_eq!(received.array.length(), 3);
467        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
468    }
469
470    #[wasm_bindgen_test]
471    async fn test_int32_array_into_transferable() {
472        let (mut left, mut right) = create_transports_simple::<Int32Array, Int32Array>().await;
473
474        dnet_tests::init_logging(&mut left, &mut right);
475
476        let array = Int32Array::new_with_length(3);
477        array.copy_from(&[1, 2, 3]);
478
479        left.send(array).await.unwrap();
480
481        let received = right.receive().await.unwrap();
482
483        assert_eq!(received.length(), 3);
484        assert_eq!(received.to_vec(), vec![1, 2, 3]);
485    }
486
487    #[wasm_bindgen_test]
488    async fn test_int32_array_into_transferable_in_derive() {
489        #[derive(Debug, IntoTransferable)]
490        struct Message {
491            #[into_transferable]
492            array: Int32Array,
493        }
494
495        #[derive(Debug, IntoTransferable)]
496        struct Empty {}
497
498        let (mut left, mut right) = create_transports::<Empty, Message>().await;
499
500        dnet_tests::init_logging(&mut left, &mut right);
501
502        let array = Int32Array::new_with_length(3);
503        array.copy_from(&[1, 2, 3]);
504
505        let message = Message { array };
506        left.send(message).await.unwrap();
507
508        let received = right.receive().await.unwrap();
509
510        assert_eq!(received.array.length(), 3);
511        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
512    }
513
514    #[wasm_bindgen_test]
515    async fn test_float16_array_into_transferable() {
516        let (mut left, mut right) = create_transports_simple::<Float16Array, Float16Array>().await;
517
518        dnet_tests::init_logging(&mut left, &mut right);
519
520        let array = Float16Array::new_with_length(3);
521        array.set_index_from_f32(0, 1.0);
522        array.set_index_from_f32(1, 2.0);
523        array.set_index_from_f32(2, 3.0);
524
525        left.send(array).await.unwrap();
526
527        let received = right.receive().await.unwrap();
528
529        assert_eq!(received.length(), 3);
530        assert_eq!(received.get_index_as_f32(0), 1.0);
531        assert_eq!(received.get_index_as_f32(1), 2.0);
532        assert_eq!(received.get_index_as_f32(2), 3.0);
533    }
534
535    #[wasm_bindgen_test]
536    async fn test_float16_array_into_transferable_in_derive() {
537        #[derive(Debug, IntoTransferable)]
538        struct Message {
539            #[into_transferable]
540            array: Float16Array,
541        }
542
543        #[derive(Debug, IntoTransferable)]
544        struct Empty {}
545
546        let (mut left, mut right) = create_transports::<Empty, Message>().await;
547
548        dnet_tests::init_logging(&mut left, &mut right);
549
550        let array = Float16Array::new_with_length(3);
551        array.set_index_from_f32(0, 1.0);
552        array.set_index_from_f32(1, 2.0);
553        array.set_index_from_f32(2, 3.0);
554
555        let message = Message { array };
556        left.send(message).await.unwrap();
557
558        let received = right.receive().await.unwrap();
559
560        assert_eq!(received.array.length(), 3);
561        assert_eq!(received.array.get_index_as_f32(0), 1.0);
562        assert_eq!(received.array.get_index_as_f32(1), 2.0);
563        assert_eq!(received.array.get_index_as_f32(2), 3.0);
564    }
565
566    #[wasm_bindgen_test]
567    async fn test_float32_array_into_transferable() {
568        let (mut left, mut right) = create_transports_simple::<Float32Array, Float32Array>().await;
569
570        dnet_tests::init_logging(&mut left, &mut right);
571
572        let array = Float32Array::new_with_length(3);
573        array.copy_from(&[1.0, 2.0, 3.0]);
574
575        left.send(array).await.unwrap();
576
577        let received = right.receive().await.unwrap();
578
579        assert_eq!(received.length(), 3);
580        assert_eq!(received.to_vec(), vec![1.0, 2.0, 3.0]);
581    }
582
583    #[wasm_bindgen_test]
584    async fn test_float32_array_into_transferable_in_derive() {
585        #[derive(Debug, IntoTransferable)]
586        struct Message {
587            #[into_transferable]
588            array: Float32Array,
589        }
590
591        #[derive(Debug, IntoTransferable)]
592        struct Empty {}
593
594        let (mut left, mut right) = create_transports::<Empty, Message>().await;
595
596        dnet_tests::init_logging(&mut left, &mut right);
597
598        let array = Float32Array::new_with_length(3);
599        array.copy_from(&[1.0, 2.0, 3.0]);
600
601        let message = Message { array };
602        left.send(message).await.unwrap();
603
604        let received = right.receive().await.unwrap();
605
606        assert_eq!(received.array.length(), 3);
607        assert_eq!(received.array.to_vec(), vec![1.0, 2.0, 3.0]);
608    }
609
610    #[wasm_bindgen_test]
611    async fn test_float64_array_into_transferable() {
612        let (mut left, mut right) = create_transports_simple::<Float64Array, Float64Array>().await;
613
614        dnet_tests::init_logging(&mut left, &mut right);
615
616        let array = Float64Array::new_with_length(3);
617        array.copy_from(&[1.0, 2.0, 3.0]);
618
619        left.send(array).await.unwrap();
620
621        let received = right.receive().await.unwrap();
622
623        assert_eq!(received.length(), 3);
624        assert_eq!(received.to_vec(), vec![1.0, 2.0, 3.0]);
625    }
626
627    #[wasm_bindgen_test]
628    async fn test_float64_array_into_transferable_in_derive() {
629        #[derive(Debug, IntoTransferable)]
630        struct Message {
631            #[into_transferable]
632            array: Float64Array,
633        }
634
635        #[derive(Debug, IntoTransferable)]
636        struct Empty {}
637
638        let (mut left, mut right) = create_transports::<Empty, Message>().await;
639
640        dnet_tests::init_logging(&mut left, &mut right);
641
642        let array = Float64Array::new_with_length(3);
643        array.copy_from(&[1.0, 2.0, 3.0]);
644
645        let message = Message { array };
646        left.send(message).await.unwrap();
647
648        let received = right.receive().await.unwrap();
649
650        assert_eq!(received.array.length(), 3);
651        assert_eq!(received.array.to_vec(), vec![1.0, 2.0, 3.0]);
652    }
653
654    #[wasm_bindgen_test]
655    async fn test_bigint64_array_into_transferable() {
656        let (mut left, mut right) =
657            create_transports_simple::<BigInt64Array, BigInt64Array>().await;
658
659        dnet_tests::init_logging(&mut left, &mut right);
660
661        let array = BigInt64Array::new_with_length(3);
662        array.copy_from(&[1, 2, 3]);
663
664        left.send(array).await.unwrap();
665
666        let received = right.receive().await.unwrap();
667
668        assert_eq!(received.length(), 3);
669        assert_eq!(received.to_vec(), vec![1, 2, 3]);
670    }
671
672    #[wasm_bindgen_test]
673    async fn test_bigint64_array_into_transferable_in_derive() {
674        #[derive(Debug, IntoTransferable)]
675        struct Message {
676            #[into_transferable]
677            array: BigInt64Array,
678        }
679
680        #[derive(Debug, IntoTransferable)]
681        struct Empty {}
682
683        let (mut left, mut right) = create_transports::<Empty, Message>().await;
684
685        dnet_tests::init_logging(&mut left, &mut right);
686
687        let array = BigInt64Array::new_with_length(3);
688        array.copy_from(&[1, 2, 3]);
689
690        let message = Message { array };
691        left.send(message).await.unwrap();
692
693        let received = right.receive().await.unwrap();
694
695        assert_eq!(received.array.length(), 3);
696        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
697    }
698
699    #[wasm_bindgen_test]
700    async fn test_biguint64_array_into_transferable() {
701        let (mut left, mut right) =
702            create_transports_simple::<BigUint64Array, BigUint64Array>().await;
703
704        dnet_tests::init_logging(&mut left, &mut right);
705
706        let array = BigUint64Array::new_with_length(3);
707        array.copy_from(&[1, 2, 3]);
708
709        left.send(array).await.unwrap();
710
711        let received = right.receive().await.unwrap();
712
713        assert_eq!(received.length(), 3);
714        assert_eq!(received.to_vec(), vec![1, 2, 3]);
715    }
716
717    #[wasm_bindgen_test]
718    async fn test_biguint64_array_into_transferable_in_derive() {
719        #[derive(Debug, IntoTransferable)]
720        struct Message {
721            #[into_transferable]
722            array: BigUint64Array,
723        }
724
725        #[derive(Debug, IntoTransferable)]
726        struct Empty {}
727
728        let (mut left, mut right) = create_transports::<Empty, Message>().await;
729
730        dnet_tests::init_logging(&mut left, &mut right);
731
732        let array = BigUint64Array::new_with_length(3);
733        array.copy_from(&[1, 2, 3]);
734
735        let message = Message { array };
736        left.send(message).await.unwrap();
737
738        let received = right.receive().await.unwrap();
739
740        assert_eq!(received.array.length(), 3);
741        assert_eq!(received.array.to_vec(), vec![1, 2, 3]);
742    }
743}