use crate::std_types::RBoxError;
#[allow(unused_imports)]
use crate::type_level::{
bools::{False, True},
impl_enum::{Implementability, Implemented, Unimplemented},
trait_marker,
};
macro_rules! declare_InterfaceType {
(
$(#[$attrs:meta])*
assoc_types[
$(
$(#[$assoc_attrs:meta])*
type $trait_:ident ;
)*
]
) => (
$(#[$attrs])*
pub trait InterfaceType: Sized {
$(
$(#[$assoc_attrs])*
type $trait_: Implementability;
)*
#[doc(hidden)]
type define_this_in_the_impl_InterfaceType_macro;
}
)
}
declare_InterfaceType! {
assoc_types[
type Send;
type Sync;
type Unpin;
type Clone;
type Default;
type Display;
type Debug;
type Serialize;
type Eq;
type PartialEq;
type Ord;
type PartialOrd;
type Hash;
type Deserialize;
type Iterator;
type DoubleEndedIterator;
type FmtWrite;
type IoWrite;
type IoSeek;
type IoRead;
type IoBufRead;
type Error;
]
}
pub trait SerializeType<'s> {
type Interface: SerializeProxyType<'s>;
fn serialize_impl(
&'s self,
) -> Result<<Self::Interface as SerializeProxyType<'s>>::Proxy, RBoxError>;
}
pub trait SerializeProxyType<'borr>: InterfaceType {
type Proxy: 'borr;
}
#[doc(hidden)]
pub trait GetSerializeProxyType<'borr>: InterfaceType {
type ProxyType;
}
impl<'borr, I, PT> GetSerializeProxyType<'borr> for I
where
I: InterfaceType,
I: GetSerializeProxyTypeHelper<'borr, <I as InterfaceType>::Serialize, ProxyType = PT>,
{
type ProxyType = PT;
}
#[doc(hidden)]
pub trait GetSerializeProxyTypeHelper<'borr, IS>: InterfaceType {
type ProxyType;
}
impl<'borr, I> GetSerializeProxyTypeHelper<'borr, Implemented<trait_marker::Serialize>> for I
where
I: SerializeProxyType<'borr>,
{
type ProxyType = <I as SerializeProxyType<'borr>>::Proxy;
}
impl<'borr, I> GetSerializeProxyTypeHelper<'borr, Unimplemented<trait_marker::Serialize>> for I
where
I: InterfaceType,
{
type ProxyType = ();
}
pub trait DeserializeDyn<'borr, D>:
InterfaceType<Deserialize = Implemented<trait_marker::Deserialize>>
{
type Proxy;
fn deserialize_dyn(s: Self::Proxy) -> Result<D, RBoxError>;
}
pub trait IteratorItem<'a>: InterfaceType {
type Item;
}
pub trait IteratorItemOrDefault<'borr>: InterfaceType {
type Item;
}
impl<'borr, I, Item> IteratorItemOrDefault<'borr> for I
where
I: InterfaceType,
I: IteratorItemOrDefaultHelper<'borr, <I as InterfaceType>::Iterator, Item = Item>,
{
type Item = Item;
}
#[doc(hidden)]
pub trait IteratorItemOrDefaultHelper<'borr, ImplIsRequired> {
type Item;
}
impl<'borr, I, Item> IteratorItemOrDefaultHelper<'borr, Implemented<trait_marker::Iterator>> for I
where
I: IteratorItem<'borr, Item = Item>,
{
type Item = Item;
}
impl<'borr, I> IteratorItemOrDefaultHelper<'borr, Unimplemented<trait_marker::Iterator>> for I {
type Item = ();
}
crate::impl_InterfaceType! {
impl crate::erased_types::InterfaceType for () {
type Send= True;
type Sync= True;
}
}