Skip to main content

dnet_js/
wrapper.rs

1//! Message wrapper for [Transport].
2//!
3//! [Transport]: super::Transport
4
5use 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
20/// Trait implemented by types using [Wrapper]-like implementation of
21/// [IntoTransferable]/[FromTransferable].
22///
23/// This is a convenience trait for use with the `IntoTransferable` derive macro
24/// to constrain generic `Into/FromTransferable` types.
25pub 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/// [Wrapper] error for [Transferable].
42#[derive(Debug)]
43pub enum Error<SerializationError, DeserializationError> {
44    /// [JsValue] was not of an expected type.
45    WrongType,
46
47    /// Error occurred during serialization of a message.
48    SerializationError(SerializationError),
49
50    /// Error occurred during deserialization of a message.
51    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/// Context needed to prepare for transfer/reconstruct [Wrapper].
80#[derive(Debug)]
81pub struct Context<Codec>
82where
83    Codec: dnet_base::Codec,
84{
85    /// Codec used to serialize/deserialize message.
86    pub codec: Codec,
87
88    /// Work buffer.
89    pub buffer: Vec<u8>,
90}
91
92impl<Codec> Context<Codec>
93where
94    Codec: dnet_base::Codec,
95{
96    /// Create new context using provided codec.
97    pub fn new(codec: Codec) -> Self {
98        Context {
99            codec,
100            buffer: vec![],
101        }
102    }
103}
104
105/// Message wrapper.
106///
107/// It uses codec from [Context] to serialize/deserialize message into/from [Uint8Array]
108/// when preparing message for transfer/reconstructing it.
109#[derive(Debug, Serialize, Deserialize)]
110pub struct Wrapper<Codec, T>
111where
112    Codec: dnet_base::Codec,
113{
114    /// Message to transfer.
115    pub message: T,
116    _codec: PhantomData<Codec>,
117}
118
119impl<Codec, T> Wrapper<Codec, T>
120where
121    Codec: dnet_base::Codec,
122{
123    /// Wrap message into [Wrapper].
124    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}