1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
use serde::{de::DeserializeOwned, Serialize}; use futures::{SinkExt, StreamExt}; use crate::{channel::Channel, kind, kind::Future, ConstructResult, DeconstructResult, Kind}; use super::{using, AsKind, WrappedError}; use core::ops::Deref; use void::Void; #[derive(Clone, Debug, Copy, Hash, Eq, Ord, PartialOrd, PartialEq, Default)] pub struct Serde<T: Serialize + DeserializeOwned + Send + 'static>(pub T); impl<T: Serialize + DeserializeOwned + Send + 'static> Serde<T> { pub fn new(item: T) -> Self { Serde(item) } } impl<T: Serialize + DeserializeOwned + Send + 'static> Deref for Serde<T> { type Target = T; fn deref(&self) -> &Self::Target { &self.0 } } impl<T: Serialize + DeserializeOwned + Send + 'static> From<T> for Serde<T> { fn from(item: T) -> Self { Serde(item) } } impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static> AsKind<using::Serde> for T { type Kind = Serde<T>; fn into_kind(self) -> Serde<T> { Serde(self) } fn from_kind(kind: Self::Kind) -> Self { kind.0 } } #[kind] impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static> Kind for Serde<T> { type ConstructItem = T; type ConstructError = WrappedError<Void>; type ConstructFuture = Future<ConstructResult<Self>>; type DeconstructItem = (); type DeconstructError = WrappedError<Void>; type DeconstructFuture = Future<DeconstructResult<Self>>; fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>( self, mut channel: C, ) -> Self::DeconstructFuture { Box::pin(async move { Ok(channel.send(self.0).await.map_err(WrappedError::Send)?) }) } fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>( mut channel: C, ) -> Self::ConstructFuture { Box::pin(async move { Ok(Serde(channel.next().await.ok_or( WrappedError::Insufficient { got: 0, expected: 1, }, )?)) }) } }