115 lines
2.8 KiB
Rust
115 lines
2.8 KiB
Rust
use std::io;
|
|
|
|
use super::Reader;
|
|
use super::Writer;
|
|
|
|
pub trait Domain: std::fmt::Debug + Eq + std::hash::Hash + Ord + Clone {
|
|
type Decode: for<'de> DomainDecode<'de, Self> + Default;
|
|
type Encode: DomainEncode<Self> + Default;
|
|
}
|
|
|
|
pub trait DomainDecode<'de, D: Domain> {
|
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
|
&mut self,
|
|
r: &mut R,
|
|
read_annotations: bool,
|
|
) -> io::Result<D>;
|
|
}
|
|
|
|
pub trait DomainEncode<D: Domain> {
|
|
fn encode_embedded(
|
|
&mut self,
|
|
w: &mut dyn Writer,
|
|
d: &D,
|
|
) -> io::Result<()>;
|
|
}
|
|
|
|
impl<'a, 'de, D: Domain, T: DomainDecode<'de, D>> DomainDecode<'de, D> for &'a mut T {
|
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
|
&mut self,
|
|
r: &mut R,
|
|
read_annotations: bool,
|
|
) -> io::Result<D> {
|
|
(**self).decode_embedded(r, read_annotations)
|
|
}
|
|
}
|
|
|
|
impl<'a, D: Domain, T: DomainEncode<D>> DomainEncode<D> for &'a mut T {
|
|
fn encode_embedded(
|
|
&mut self,
|
|
w: &mut dyn Writer,
|
|
d: &D,
|
|
) -> io::Result<()> {
|
|
(**self).encode_embedded(w, d)
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct DefaultDomainCodec;
|
|
|
|
impl<'de, D: Domain> DomainDecode<'de, D> for DefaultDomainCodec {
|
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
|
&mut self,
|
|
r: &mut R,
|
|
read_annotations: bool,
|
|
) -> io::Result<D> {
|
|
D::Decode::default().decode_embedded(r, read_annotations)
|
|
}
|
|
}
|
|
|
|
impl<D: Domain> DomainEncode<D> for DefaultDomainCodec {
|
|
fn encode_embedded(
|
|
&mut self,
|
|
w: &mut dyn Writer,
|
|
d: &D,
|
|
) -> io::Result<()> {
|
|
D::Encode::default().encode_embedded(w, d)
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct DebugDomainCodec;
|
|
|
|
impl<'de, Err: Into<io::Error>, D: Domain + std::str::FromStr<Err = Err>> DomainDecode<'de, D> for DebugDomainCodec {
|
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
|
&mut self,
|
|
r: &mut R,
|
|
_read_annotations: bool,
|
|
) -> io::Result<D> {
|
|
r.next_str()?.parse().map_err(|e: Err| e.into())
|
|
}
|
|
}
|
|
|
|
impl<D: Domain> DomainEncode<D> for DebugDomainCodec {
|
|
fn encode_embedded(
|
|
&mut self,
|
|
w: &mut dyn Writer,
|
|
d: &D,
|
|
) -> io::Result<()> {
|
|
w.write_string(&format!("{:?}", d))
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct NoEmbeddedDomainCodec;
|
|
|
|
impl<'de, D: Domain> DomainDecode<'de, D> for NoEmbeddedDomainCodec {
|
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
|
&mut self,
|
|
_r: &mut R,
|
|
_read_annotations: bool,
|
|
) -> io::Result<D> {
|
|
Err(io::Error::new(io::ErrorKind::Unsupported, "Embedded values not supported here"))
|
|
}
|
|
}
|
|
|
|
impl<D: Domain> DomainEncode<D> for NoEmbeddedDomainCodec {
|
|
fn encode_embedded(
|
|
&mut self,
|
|
_w: &mut dyn Writer,
|
|
_d: &D,
|
|
) -> io::Result<()> {
|
|
Err(io::Error::new(io::ErrorKind::Unsupported, "Embedded values not supported here"))
|
|
}
|
|
}
|