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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
use core::task::{Context, Poll};
use crate::backend::{Format, FormatEncode};
use crate::io;
pub enum StartEncodeStatus<Enc, Err> {
Fini,
Pending(Enc),
Error(Err),
}
impl<Enc, Err> StartEncodeStatus<Enc, Err> {
#[inline(always)]
pub fn map_pending<F, E>(self, f: F) -> StartEncodeStatus<E, Err>
where
F: FnOnce(Enc) -> E,
{
match self {
Self::Fini => StartEncodeStatus::Fini,
Self::Pending(enc) => StartEncodeStatus::Pending(f(enc)),
Self::Error(e) => StartEncodeStatus::Error(e),
}
}
}
pub enum PollEncodeStatus<Err> {
Fini,
Pending,
Error(Err),
}
impl<Err> PollEncodeStatus<Err> {
#[inline(always)]
pub fn lift<Enc>(self, enc: Enc) -> StartEncodeStatus<Enc, Err> {
match self {
PollEncodeStatus::Fini => StartEncodeStatus::Fini,
PollEncodeStatus::Pending => StartEncodeStatus::Pending(enc),
PollEncodeStatus::Error(err) => StartEncodeStatus::Error(err),
}
}
#[inline(always)]
pub fn map_err<F, E>(self, f: F) -> PollEncodeStatus<E>
where
F: FnOnce(Err) -> E,
{
match self {
PollEncodeStatus::Fini => PollEncodeStatus::Fini,
PollEncodeStatus::Pending => PollEncodeStatus::Pending,
PollEncodeStatus::Error(err) => PollEncodeStatus::Error(f(err))
}
}
}
impl<Err> From<PollEncodeStatus<Err>> for Poll<Result<(), Err>> {
#[inline(always)]
fn from(status: PollEncodeStatus<Err>) -> Self {
match status {
PollEncodeStatus::Fini => Poll::Ready(Ok(())),
PollEncodeStatus::Pending => Poll::Pending,
PollEncodeStatus::Error(e) => Poll::Ready(Err(e)),
}
}
}
pub trait Encode: Sized {
type Format: FormatEncode;
type Data: ?Sized;
fn init(data: &Self::Data) -> Self;
fn start_encode<W>(format: &Self::Format, writer: &mut W, data: &Self::Data, cx: &mut Context<'_>) -> StartEncodeStatus<Self, <<Self as Encode>::Format as Format>::Error>
where
W: io::AsyncWrite + Unpin,
{
let mut enc = Self::init(data);
enc.poll_encode(format, writer, data, cx)
.lift(enc)
}
fn poll_encode<W>(&mut self, format: &Self::Format, writer: &mut W, data: &Self::Data, cx: &mut Context<'_>) -> PollEncodeStatus<<<Self as Encode>::Format as Format>::Error>
where
W: io::AsyncWrite + Unpin,
;
}