@@ -15,23 +15,118 @@ cfg_if::cfg_if! {
1515 impl <T : Read + Seek + Send + Sync > ReplayReader for T { }
1616
1717 } else {
18- use core:: { convert:: AsRef , iter:: Extend } ;
18+ use core:: iter:: Extend ;
19+ use postcard:: { ser_flavors, de_flavors} ;
20+
21+ type PcError = postcard:: Error ;
22+ type PcResult <T > = postcard:: Result <T >;
1923
2024 /// A writer for recording in RR.
21- pub trait RecordWriter : Extend <u8 > + Send + Sync + Any { }
22- impl <T : Extend <u8 > + Send + Sync + Any > RecordWriter for T { }
25+ ///
26+ /// In `no_std`, types must provide explicit write capabilities.
27+ pub trait RecordWriter : Send + Sync + Any {
28+ /// Write all the bytes from `buf` to the writer
29+ fn write( & mut self , buf: & [ u8 ] ) -> Result <usize >;
30+ /// Flush the writer
31+ fn flush( & mut self ) -> Result <( ) >;
32+ }
33+ impl <T : Send + Sync + Any + Extend <u8 >> RecordWriter for T {
34+ fn write( & mut self , buf: & [ u8 ] ) -> Result <usize > {
35+ self . extend( buf. iter( ) . copied( ) ) ;
36+ Ok ( buf. len( ) )
37+ }
38+ fn flush( & mut self ) -> Result <( ) > {
39+ Ok ( ( ) )
40+ }
41+ }
2342
2443 /// A reader for replaying in RR.
2544///
26- /// In `no_std`, types must provide explicit read/seek capabilities
27- /// to a underlying byte slice through these methods.
28- pub trait ReplayReader : AsRef <[ u8 ] > + Send + Sync {
29- /// Advance the reader's internal cursor by `cnt` bytes
30- fn advance( & mut self , cnt: usize ) ;
31- /// Seek to an absolute position `pos` in the reader
45+ /// In `no_std`, types must provide explicit read/seek capabilities.
46+ pub trait ReplayReader : Send + Sync {
47+ /// Read bytes into `buf`, returning number of bytes read.
48+ fn read( & mut self , buf: & mut [ u8 ] ) -> Result <usize >;
49+ /// Seek to an absolute position `pos` in the reader.
3250fn seek( & mut self , pos: usize ) ;
3351 }
3452
53+ /// Resembles a `WriteFlavor` in postcard
54+ struct RecordWriterFlavor <' a, W : RecordWriter + ?Sized > {
55+ writer: & ' a mut W ,
56+ }
57+
58+ impl <' a, W : RecordWriter + ?Sized > ser_flavors:: Flavor for RecordWriterFlavor <' a, W > {
59+ type Output = ( ) ;
60+
61+ #[ inline]
62+ fn try_push( & mut self , data: u8 ) -> PcResult <( ) > {
63+ self . writer. write( & [ data] ) . map_err( |_| PcError :: SerializeBufferFull ) ?;
64+ Ok ( ( ) )
65+ }
66+ #[ inline]
67+ fn try_extend( & mut self , data: & [ u8 ] ) -> PcResult <( ) > {
68+ self . writer. write( data) . map_err( |_| PcError :: SerializeBufferFull ) ?;
69+ Ok ( ( ) )
70+ }
71+ #[ inline]
72+ fn finalize( self ) -> PcResult <Self :: Output > {
73+ self . writer. flush( ) . map_err( |_| PcError :: SerializeBufferFull ) ?;
74+ Ok ( ( ) )
75+ }
76+ }
77+
78+ struct ReplayReaderFlavor <' a, ' b, R : ReplayReader + ?Sized > {
79+ reader: & ' a mut R ,
80+ scratch: & ' b mut [ u8 ] ,
81+ }
82+
83+ impl <' de, ' a, ' b, R : ReplayReader + ?Sized > de_flavors:: Flavor <' de> for ReplayReaderFlavor <' a, ' b, R >
84+ where ' b: ' de, ' a: ' de
85+ {
86+ type Remainder = ( ) ;
87+ type Source = ( ) ;
88+
89+ #[ inline]
90+ fn pop( & mut self ) -> PcResult <u8 > {
91+ let scratch = core:: mem:: replace( & mut self . scratch, & mut [ ] ) ;
92+ if scratch. is_empty( ) {
93+ return PcResult :: Err ( PcError :: DeserializeUnexpectedEnd ) ;
94+ }
95+ let ( slice, rest) = scratch. split_at_mut( 1 ) ;
96+ self . scratch = rest;
97+
98+ match self . reader. read( slice) {
99+ Ok ( 1 ) => Ok ( slice[ 0 ] ) ,
100+ _ => PcResult :: Err ( PcError :: DeserializeUnexpectedEnd ) ,
101+ }
102+ }
103+
104+ #[ inline]
105+ fn try_take_n( & mut self , ct: usize ) -> postcard:: Result <& ' de [ u8 ] > {
106+ let scratch = core:: mem:: replace( & mut self . scratch, & mut [ ] ) ;
107+ if scratch. len( ) < ct {
108+ return PcResult :: Err ( PcError :: DeserializeUnexpectedEnd ) ;
109+ }
110+ let ( slice, rest) = scratch. split_at_mut( ct) ;
111+ self . scratch = rest;
112+
113+ let mut total_read = 0 ;
114+ while total_read < ct {
115+ match self . reader. read( & mut slice[ total_read..] ) {
116+ Ok ( 0 ) => return PcResult :: Err ( PcError :: DeserializeUnexpectedEnd ) ,
117+ Ok ( n) => total_read += n,
118+ Err ( _) => return PcResult :: Err ( PcError :: DeserializeUnexpectedEnd ) ,
119+ }
120+ }
121+
122+ Ok ( slice)
123+ }
124+
125+ #[ inline]
126+ fn finalize( self ) -> PcResult <Self :: Remainder > {
127+ Ok ( ( ) )
128+ }
129+ }
35130 }
36131}
37132
@@ -41,15 +136,16 @@ cfg_if::cfg_if! {
41136pub ( super ) fn to_record_writer < T , W > ( value : & T , writer : & mut W ) -> Result < ( ) >
42137where
43138 T : Serialize + ?Sized ,
44- W : RecordWriter ,
139+ W : RecordWriter + ? Sized ,
45140{
46141 #[ cfg( feature = "std" ) ]
47142 {
48143 postcard:: to_io ( value, writer) ?;
49144 }
50145 #[ cfg( not( feature = "std" ) ) ]
51146 {
52- postcard:: to_extend ( value, writer) ?;
147+ let flavor = RecordWriterFlavor { writer } ;
148+ postcard:: serialize_with_flavor ( value, flavor) ?;
53149 }
54150 Ok ( ( ) )
55151}
@@ -61,18 +157,18 @@ where
61157pub ( super ) fn from_replay_reader < ' a , T , R > ( reader : & ' a mut R , scratch : & ' a mut [ u8 ] ) -> Result < T >
62158where
63159 T : Deserialize < ' a > ,
64- R : ReplayReader ,
160+ R : ReplayReader + ? Sized ,
65161{
66162 #[ cfg( feature = "std" ) ]
67163 {
68164 Ok ( postcard:: from_io ( ( reader, scratch) ) ?. 0 )
69165 }
70166 #[ cfg( not( feature = "std" ) ) ]
71167 {
72- let bytes = reader. as_ref ( ) ;
73- let original_len = bytes . len ( ) ;
74- let ( value , new ) = postcard :: take_from_bytes ( bytes ) ?;
75- reader . advance ( new . len ( ) - original_len ) ;
76- Ok ( value )
168+ let flavor = ReplayReaderFlavor { reader, scratch } ;
169+ let mut deserializer = postcard :: Deserializer :: from_flavor ( flavor ) ;
170+ let t = T :: deserialize ( & mut deserializer ) ?;
171+ deserializer . finalize ( ) ? ;
172+ Ok ( t )
77173 }
78174}
0 commit comments