Skip to main content

wry_bindgen_core/
clamped.rs

1//! Support for JavaScript `Uint8ClampedArray` values.
2
3use alloc::vec::Vec;
4use core::ops::{Deref, DerefMut};
5
6use wry_bindgen_runtime::wire::{
7    BinaryDecode, BinaryEncode, DecodeError, DecodedData, EncodeTypeDef, EncodedData, TypeDef,
8};
9
10use crate::BatchableResult;
11
12/// A wrapper type around slices and vectors for binding `Uint8ClampedArray`.
13#[derive(Copy, Clone, PartialEq, Debug, Eq)]
14pub struct Clamped<T>(pub T);
15
16impl<T> Deref for Clamped<T> {
17    type Target = T;
18
19    fn deref(&self) -> &T {
20        &self.0
21    }
22}
23
24impl<T> DerefMut for Clamped<T> {
25    fn deref_mut(&mut self) -> &mut T {
26        &mut self.0
27    }
28}
29
30impl EncodeTypeDef for Clamped<Vec<u8>> {
31    fn encode_type_def(type_def: &mut TypeDef) {
32        type_def.u8_clamped();
33    }
34}
35
36impl EncodeTypeDef for Clamped<&[u8]> {
37    fn encode_type_def(type_def: &mut TypeDef) {
38        type_def.u8_clamped();
39    }
40}
41
42impl EncodeTypeDef for Clamped<&mut [u8]> {
43    fn encode_type_def(type_def: &mut TypeDef) {
44        type_def.u8_clamped();
45    }
46}
47
48impl BinaryEncode for Clamped<Vec<u8>> {
49    fn encode(self, encoder: &mut EncodedData) {
50        (self.0.len() as u32).encode(encoder);
51        for val in self.0 {
52            val.encode(encoder);
53        }
54    }
55}
56
57impl BinaryEncode for Clamped<&[u8]> {
58    fn encode(self, encoder: &mut EncodedData) {
59        (self.0.len() as u32).encode(encoder);
60        for &val in self.0 {
61            val.encode(encoder);
62        }
63    }
64}
65
66impl BinaryEncode for Clamped<&mut [u8]> {
67    fn encode(self, encoder: &mut EncodedData) {
68        (self.0.len() as u32).encode(encoder);
69        for &mut val in self.0 {
70            val.encode(encoder);
71        }
72    }
73}
74
75impl BinaryDecode for Clamped<Vec<u8>> {
76    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
77        let len = u32::decode(decoder)? as usize;
78        let mut vec = Vec::with_capacity(len);
79        for _ in 0..len {
80            vec.push(u8::decode(decoder)?);
81        }
82        Ok(Clamped(vec))
83    }
84}
85
86impl BatchableResult for Clamped<Vec<u8>> {}