1use std::{
6 fmt::{Debug, Display},
7 marker::PhantomData,
8};
9
10use dnet_base::{Codec, Decode, Encode};
11use dnet_utils::unwrap::Unwrap;
12use js_sys::{Array, Uint8Array};
13use serde::{Deserialize, Serialize};
14use wasm_bindgen::{JsCast, JsValue};
15
16use crate::transferable::{FromTransferable, IntoTransferable};
17
18use super::{Transferable, WithTransferable};
19
20pub trait WrapperLikeTransferable<C>:
26 IntoTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
27 + FromTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
28where
29 C: Codec,
30{
31}
32
33impl<C, T> WrapperLikeTransferable<C> for T
34where
35 T: IntoTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
36 + FromTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>,
37 C: Codec,
38{
39}
40
41#[derive(Debug)]
43pub enum Error<SerializationError, DeserializationError> {
44 WrongType,
46
47 SerializationError(SerializationError),
49
50 DeserializationError(DeserializationError),
52}
53
54impl<SerializationError, DeserializationError> Display
55 for Error<SerializationError, DeserializationError>
56where
57 SerializationError: Display,
58 DeserializationError: Display,
59{
60 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
61 match self {
62 Error::WrongType => write!(f, "unexpected JS value type"),
63 Error::SerializationError(error) => write!(f, "failed to serialize message: {error}"),
64 Error::DeserializationError(error) => {
65 write!(f, "failed to deserialize message: {error}")
66 }
67 }
68 }
69}
70
71impl<SerializationError, DeserializationError> std::error::Error
72 for Error<SerializationError, DeserializationError>
73where
74 SerializationError: Debug + Display,
75 DeserializationError: Debug + Display,
76{
77}
78
79#[derive(Debug)]
81pub struct Context<Codec>
82where
83 Codec: dnet_base::Codec,
84{
85 pub codec: Codec,
87
88 pub buffer: Vec<u8>,
90}
91
92impl<Codec> Context<Codec>
93where
94 Codec: dnet_base::Codec,
95{
96 pub fn new(codec: Codec) -> Self {
98 Context {
99 codec,
100 buffer: vec![],
101 }
102 }
103}
104
105#[derive(Debug, Serialize, Deserialize)]
110pub struct Wrapper<Codec, T>
111where
112 Codec: dnet_base::Codec,
113{
114 pub message: T,
116 _codec: PhantomData<Codec>,
117}
118
119impl<Codec, T> Wrapper<Codec, T>
120where
121 Codec: dnet_base::Codec,
122{
123 pub fn new(message: T) -> Self {
125 Wrapper {
126 message,
127 _codec: PhantomData,
128 }
129 }
130}
131
132impl<Codec, T> Unwrap for Wrapper<Codec, T>
133where
134 Codec: dnet_base::Codec,
135{
136 type Output = T;
137
138 fn unwrap(self) -> Self::Output {
139 self.message
140 }
141}
142
143impl<Codec, T> Transferable for Wrapper<Codec, T>
144where
145 Codec: dnet_base::Codec,
146 T: Serialize,
147 for<'de> T: serde::de::Deserialize<'de>,
148{
149 type Context = Context<Codec>;
150 type Error = Error<<Codec as Encode>::Error, <Codec as Decode>::Error>;
151
152 fn prepare_for_transfer(
153 self,
154 context: &mut Self::Context,
155 ) -> Result<WithTransferable, Self::Error> {
156 context.buffer.clear();
157 context
158 .codec
159 .encode(&mut context.buffer, &self)
160 .map_err(Error::SerializationError)?;
161 let data = Uint8Array::from(&context.buffer[..]);
162 let transfer = Array::of1(&data.buffer());
163 Ok(WithTransferable {
164 data: data.into(),
165 transfer,
166 })
167 }
168
169 fn reconstruct(object: JsValue, context: &mut Self::Context) -> Result<Self, Self::Error>
170 where
171 Self: Sized,
172 {
173 let data = object
174 .dyn_into::<Uint8Array>()
175 .map_err(|_| Error::WrongType)?;
176 context
177 .codec
178 .decode(&data.to_vec()[..])
179 .map_err(Error::DeserializationError)
180 }
181}
182
183impl<Codec, T>
184 IntoTransferable<Context<Codec>, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>
185 for Wrapper<Codec, T>
186where
187 Codec: dnet_base::Codec,
188 T: Serialize,
189 for<'de> T: serde::de::Deserialize<'de>,
190{
191 type Output = Wrapper<Codec, T>;
192
193 fn into_transferable(self) -> Self::Output {
194 self
195 }
196}
197
198impl<Codec, T>
199 FromTransferable<Context<Codec>, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>
200 for Wrapper<Codec, T>
201where
202 Codec: dnet_base::Codec,
203 T: Serialize,
204 for<'de> T: serde::de::Deserialize<'de>,
205{
206 type Input = Wrapper<Codec, T>;
207
208 fn from_transferable(input: Self::Input) -> Self {
209 input
210 }
211}