1use 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
19pub trait TypedArray: JsCast {
21 fn array_buffer(&self) -> ArrayBuffer;
23}
24
25pub struct Wrapper<Codec, T>
30where
31 T: TypedArray,
32{
33 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}