use std::{
fmt::{Debug, Display},
marker::PhantomData,
};
use dnet_base::{Codec, Decode, Encode};
use dnet_utils::unwrap::Unwrap;
use js_sys::{Array, Uint8Array};
use serde::{Deserialize, Serialize};
use wasm_bindgen::{JsCast, JsValue};
use crate::transferable::{FromTransferable, IntoTransferable};
use super::{Transferable, WithTransferable};
pub trait WrapperLikeTransferable<C>:
IntoTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
+ FromTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
where
C: Codec,
{
}
impl<C, T> WrapperLikeTransferable<C> for T
where
T: IntoTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>
+ FromTransferable<Context<C>, Error<<C as Encode>::Error, <C as Decode>::Error>>,
C: Codec,
{
}
#[derive(Debug)]
pub enum Error<SerializationError, DeserializationError> {
WrongType,
SerializationError(SerializationError),
DeserializationError(DeserializationError),
}
impl<SerializationError, DeserializationError> Display
for Error<SerializationError, DeserializationError>
where
SerializationError: Display,
DeserializationError: Display,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::WrongType => write!(f, "unexpected JS value type"),
Error::SerializationError(error) => write!(f, "failed to serialize message: {error}"),
Error::DeserializationError(error) => {
write!(f, "failed to deserialize message: {error}")
}
}
}
}
impl<SerializationError, DeserializationError> std::error::Error
for Error<SerializationError, DeserializationError>
where
SerializationError: Debug + Display,
DeserializationError: Debug + Display,
{
}
#[derive(Debug)]
pub struct Context<Codec>
where
Codec: dnet_base::Codec,
{
pub codec: Codec,
pub buffer: Vec<u8>,
}
impl<Codec> Context<Codec>
where
Codec: dnet_base::Codec,
{
pub fn new(codec: Codec) -> Self {
Context {
codec,
buffer: vec![],
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
{
pub message: T,
_codec: PhantomData<Codec>,
}
impl<Codec, T> Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
{
pub fn new(message: T) -> Self {
Wrapper {
message,
_codec: PhantomData,
}
}
}
impl<Codec, T> Unwrap for Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
{
type Output = T;
fn unwrap(self) -> Self::Output {
self.message
}
}
impl<Codec, T> Transferable for Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
T: Serialize,
for<'de> T: serde::de::Deserialize<'de>,
{
type Context = Context<Codec>;
type Error = Error<<Codec as Encode>::Error, <Codec as Decode>::Error>;
fn prepare_for_transfer(
self,
context: &mut Self::Context,
) -> Result<WithTransferable, Self::Error> {
context.buffer.clear();
context
.codec
.encode(&mut context.buffer, &self)
.map_err(Error::SerializationError)?;
let data = Uint8Array::from(&context.buffer[..]);
let transfer = Array::of1(&data.buffer());
Ok(WithTransferable {
data: data.into(),
transfer,
})
}
fn reconstruct(object: JsValue, context: &mut Self::Context) -> Result<Self, Self::Error>
where
Self: Sized,
{
let data = object
.dyn_into::<Uint8Array>()
.map_err(|_| Error::WrongType)?;
context
.codec
.decode(&data.to_vec()[..])
.map_err(Error::DeserializationError)
}
}
impl<Codec, T>
IntoTransferable<Context<Codec>, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>
for Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
T: Serialize,
for<'de> T: serde::de::Deserialize<'de>,
{
type Output = Wrapper<Codec, T>;
fn into_transferable(self) -> Self::Output {
self
}
}
impl<Codec, T>
FromTransferable<Context<Codec>, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>
for Wrapper<Codec, T>
where
Codec: dnet_base::Codec,
T: Serialize,
for<'de> T: serde::de::Deserialize<'de>,
{
type Input = Wrapper<Codec, T>;
fn from_transferable(input: Self::Input) -> Self {
input
}
}