1+ use crate :: error:: { self , Error , ErrorImpl , Result } ;
12use crate :: path:: Path ;
2- use crate :: { error, Error , Result } ;
33use serde:: de:: {
44 self , Deserialize , DeserializeOwned , DeserializeSeed , Expected , IgnoredAny as Ignore ,
55 IntoDeserializer , Unexpected , Visitor ,
@@ -10,7 +10,10 @@ use std::f64;
1010use std:: fmt;
1111use std:: io;
1212use std:: marker:: PhantomData ;
13+ use std:: mem;
1314use std:: str;
15+ use std:: sync:: atomic:: { AtomicUsize , Ordering } ;
16+ use std:: sync:: Arc ;
1417use yaml_rust:: parser:: { Event as YamlEvent , MarkedEventReceiver , Parser } ;
1518use yaml_rust:: scanner:: { Marker , TScalarStyle , TokenType } ;
1619
@@ -23,6 +26,8 @@ enum Input<'a> {
2326 Str ( & ' a str ) ,
2427 Slice ( & ' a [ u8 ] ) ,
2528 Read ( Box < dyn io:: Read + ' a > ) ,
29+ Multidoc ( Arc < Multidoc > ) ,
30+ Fail ( Arc < ErrorImpl > ) ,
2631}
2732
2833impl < ' a > Deserializer < ' a > {
@@ -52,7 +57,23 @@ impl<'a> Deserializer<'a> {
5257 }
5358
5459 fn de < T > ( self , f : impl FnOnce ( & mut DeserializerFromEvents ) -> Result < T > ) -> Result < T > {
60+ if let Input :: Multidoc ( multidoc) = & self . input {
61+ let mut pos = multidoc. pos . load ( Ordering :: Relaxed ) ;
62+ let t = f ( & mut DeserializerFromEvents {
63+ events : & multidoc. loader . events ,
64+ aliases : & multidoc. loader . aliases ,
65+ pos : & mut pos,
66+ path : Path :: Root ,
67+ remaining_depth : 128 ,
68+ } ) ?;
69+ multidoc. pos . store ( pos, Ordering :: Relaxed ) ;
70+ return Ok ( t) ;
71+ }
72+
5573 let loader = loader ( self . input ) ?;
74+ if loader. events . is_empty ( ) {
75+ return Err ( error:: end_of_stream ( ) ) ;
76+ }
5677 let mut pos = 0 ;
5778 let t = f ( & mut DeserializerFromEvents {
5879 events : & loader. events ,
@@ -84,6 +105,8 @@ fn loader(input: Input) -> Result<Loader> {
84105 rdr. read_to_end ( & mut buffer) . map_err ( error:: io) ?;
85106 Input2 :: Slice ( & buffer)
86107 }
108+ Input :: Multidoc ( _) => unreachable ! ( ) ,
109+ Input :: Fail ( err) => return Err ( error:: shared ( err) ) ,
87110 } ;
88111
89112 let input = match input {
@@ -97,10 +120,62 @@ fn loader(input: Input) -> Result<Loader> {
97120 aliases : BTreeMap :: new ( ) ,
98121 } ;
99122 parser. load ( & mut loader, true ) . map_err ( error:: scanner) ?;
100- if loader. events . is_empty ( ) {
101- Err ( error:: end_of_stream ( ) )
102- } else {
103- Ok ( loader)
123+ Ok ( loader)
124+ }
125+
126+ struct Multidoc {
127+ loader : Loader ,
128+ pos : AtomicUsize ,
129+ }
130+
131+ impl < ' de > Iterator for Deserializer < ' de > {
132+ type Item = Self ;
133+
134+ fn next ( & mut self ) -> Option < Self > {
135+ match & self . input {
136+ Input :: Multidoc ( multidoc) => {
137+ let pos = multidoc. pos . load ( Ordering :: Relaxed ) ;
138+ return if pos < multidoc. loader . events . len ( ) {
139+ Some ( Deserializer {
140+ input : Input :: Multidoc ( Arc :: clone ( multidoc) ) ,
141+ } )
142+ } else {
143+ None
144+ } ;
145+ }
146+ Input :: Fail ( err) => {
147+ return Some ( Deserializer {
148+ input : Input :: Fail ( Arc :: clone ( err) ) ,
149+ } ) ;
150+ }
151+ _ => { }
152+ }
153+
154+ let dummy = Input :: Str ( "" ) ;
155+ let input = mem:: replace ( & mut self . input , dummy) ;
156+ match loader ( input) {
157+ Ok ( loader) => {
158+ let multidoc = Arc :: new ( Multidoc {
159+ loader,
160+ pos : AtomicUsize :: new ( 0 ) ,
161+ } ) ;
162+ self . input = Input :: Multidoc ( Arc :: clone ( & multidoc) ) ;
163+ if multidoc. loader . events . is_empty ( ) {
164+ None
165+ } else {
166+ Some ( Deserializer {
167+ input : Input :: Multidoc ( multidoc) ,
168+ } )
169+ }
170+ }
171+ Err ( err) => {
172+ let fail = err. shared ( ) ;
173+ self . input = Input :: Fail ( Arc :: clone ( & fail) ) ;
174+ Some ( Deserializer {
175+ input : Input :: Fail ( fail) ,
176+ } )
177+ }
178+ }
104179 }
105180}
106181
0 commit comments