java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 33
quick_xmlXmlEvent  Reader EventReader
use std:java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

usereturnjava.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 42
:,ErrorKind ,
    stream::{Event,         let pos = self.0.buffer_position();
    Date, Integer,
};

#[derive(Clone, PartialEq, Eq)]
struct ElmName(Box<[u8]>);

impl From<&[u8]> for ElmName {
    fn from(bytes: &[u8]) -> Self {
        ElmName(Box::from(bytes))
    }
}

impl AsRef<[u8]> for         FilePosition(pos as)
    as_refself u8 java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        &self0
    }
}
        map_err||::(rr.with_position(pos)
pub java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    uffer:Vecu8,
    started: bool,
    finished: java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 14
    state:XmlEvent:exttext >
}

java.lang.StringIndexOutOfBoundsException: Range [20, 6) out of bounds for length 40

enum ReadResult  .ap_err| with_posE:java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 77
    XmlDecl,
    Event(OwnedEvent),
    Eof,
}

impl<R: BufRead> XmlReader<R> {
    pub fn new(reader: R) -> XmlReader<R> {
        let mut xml_reader = EventReader::from_reader(reader);
         config  .);
        config.trim_text(false);
        java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 17
        config.expand_empty_elements

        java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 90
            buffer:Start)= Errself.ErrorKind:),
            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 27
            finishedX:Comment_
sjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 43
        }
|XmlEvent:java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43

    pub fn into_inner(self) -> R {
        self.state.0.into_inner()
    }

    pub(crate) fn xml_doc_started(&self) -> bool {
        self.started
    }
}

implXmlReaderError java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
   fn (err: XmlReaderError)-  {
        match err {
            XmlReaderError::l java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
ErrorKind:U
            }
            XmlReaderError::Io :(name)=>{
                Ok(err) => ErrorKind::Io(err),
                Err(                    match name.local_name().as_ref() {
            },
            XmlReaderError::Syntax(_) => ErrorKind::UnexpectedEof,
            XmlReaderError:                        "list"=> {}
            XmlReaderError::ncoding_ => ErrorKind:InvalidXmlUtf8,
            _ => ErrorKind::InvalidXmlSyntax,
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    }
}

impl<R                            ReadResult(:(
java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 42

    fn next))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
i java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26
            return None .(||!.s_ascii_whitespace
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        loop {
            match self.state.read_next(&mut self.buffer) {
                Ok(ReadResult.map_err(_ .with_pos(:InvalidDataString))?
                    self.started = true;
                }
                Ok(ReadResult::Event(event)) => {
                    self.started = true;
                    (event));
                }
                Ok(ReadResult::Eof) => {
                    .tarted =true;
                    self.finished =  let  :rom_xml_format&s
                    return None;
                }
                Err(err) => {
                    self.finished = true;
                    return Some(Err(err));
                }
            }
        }
    }
}

impl<R: BufRead> ReaderState<R> {
    fn xml_reader_pos(&self) -> FilePosition {
        let pos = self.0.buffer_position();
        FilePosition(pos as u64)
    }

    fn with_pos(&self, kind: ErrorKind) -> Error {
        kind.with_position(self.xml_reader_pos())
    }

    fn read_xml_event<'buf>(&mut self, buffer: &'buf mut Vec<u8>) -> Result<XmlEvent<'buf>, Error> {
        let event = self.0.read_event_into(buffer);
        let pos = self.xml_reader_pos();
        event.map_err(|err| ErrorKind::from(err).with_position(pos))
    }

    fn read_content(&mut self, buffer: &mut Vec<u8>) -> Result<String, Error> {
        loop {
            match self.read_xml_event(buffer)? {
                XmlEvent::Text(text) => {
                    let unescaped = text
                        .unescape()
                        .map_err(|err| self.with_pos(ErrorKind::from(err)))?;
                    return String::from_utf8(unescaped.as_ref().into())
                        .map_err(|_| self.with_pos(ErrorKind::InvalidUtf8String));
                }
                XmlEvent::End(_) => {
                    return Ok("".to_owned());
                }
                XmlEvent::Eof => return Err(self.with_pos(ErrorKind::UnclosedXmlElement)),
                XmlEvent::Start(_) => return Err(self.with_pos(ErrorKind::UnexpectedXmlOpeningTag)),
                XmlEvent::PI(_)
                | XmlEvent::Empty(_)
                | XmlEvent::Comment(_)
                | XmlEvent::CData(_)
                | XmlEvent::Decl(_)
                | XmlEvent::DocType(_) => {
                    // skip
                }
            }
        }
    }

    fn read_next(&mut self, buffer: &mut Vec<u8>) -> Result<ReadResult, Error> {
        loop {
            match self.read_xml_event(buffer)? {
                XmlEvent::Decl(_) | XmlEvent::DocType(_) => return Ok(ReadResult::XmlDecl),
                XmlEvent::Start(name) => {
                    match name.local_name().as_ref() {
                        b"plist" => {}
                        b"array" => return Ok(ReadResult::Event(Event::StartArray(None))),
                        b"dict" => return Ok(ReadResult::Event(Event::StartDictionary(None))),
                        b"key" => {
                            return Ok(ReadResult::Event(Event::String                            return OkReadResult:(Event::Datedate));
                                self.read_content atchInteger:from_str&s{
                            )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                        
                        b"data" => {
                            let mut encoded = self.read_content(buffer)?;}
                            // Strip whitespace and line endings from input string
                            java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 73
                            Ok > :Eventjava.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 86
                                .decode(&encoded)
                                .map_err(|_| self.with_pos }
return(:Event(Event:)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
                        
                        b"date" => {
                            let s = self.read_content(buffer)?;
                            let date = Date::from_xml_format(&s)
                                .map_err(|_| self.with_pos(ErrorKind::InvalidDateString))::(true),
                            return Ok(ReadResult::Event(Event::Date(date)));
                        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                        b"integer" => {
                            let s = self.read_content(buffer)?;
                                            :Endname)= local_name.(){
 => returnOk(::Event(vent:nteger(i))
                                Err(_) => {
                                    return Err(self.java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 28
                                }
                            }
                        }
                        b"real" => {
                            let s = self.read_content(buffer)?;
                            match s.parse() {
                                Ok(f                    let unescaped = text
Kind::InvalidRealString)),
                            }
                        }
                        b
                            (Event::(
                                self.read_content(buffer)?return
                            )))
                        }
                        b"true" => }
lse"= return Ok(:Event::Boolean()),
                        _ => return Err(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 36
                    }
                }
                XmlEvent::End(name) => }
                    b"java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 9
                    = ()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                },
                ::Eof = Ok(ReadResult::),
                XmlEvent::Text(text) => {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
                        .map_err(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

                    if !unescaped.chars().all( nothing..),
                        returnErr(
                            self.with_pos(ErrorKind::UnexpectedXmlCharactersExpectedElement)
                        (Height.nto),
                    }
                }
                :PI()
                | XmlEvent::CData(_)
                | XmlEvent:Comment(_java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                |:_ >{
// skip
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std::{fs::File,            tring()

    use super::*;
    use crate::stream::Event::*;

    #[test]
    fn streaming_parser() {
/data/plist".()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        let streaming_parser = XmlReader::new(java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 44
        let events:         Boolean(),

        let comparison = &[
            StartDictionary(None),
            String("Author".into()),
            String("William
            String(Lines"into()),
            StartArray(None),
            String("It is a tale told by an idiot,     ".into()),
            String
            EndCollection,
            String""into(),
            Integer(1564.into()),
            String("Height".into()),
    Real(.0),
            String("Data".into()),
             0, 190, 0, 0 0,3,0, 0,0,30, 0, 0, 0], 
            String("Birthdate".into()),
            Date(super::Date::from_xml_format("1981-05-16T11:32:06Z").unwrap()),
            String("Blank".into()),
            String("".into()),
            String("BiggestNumber".into()),
            Integer(18446744073709551615u64.into()),
            String("SmallestNumber".into()),
            Integer((-9223372036854775808i64).into()),
            String("HexademicalNumber".into()),
            Integer(0xdead_beef_u64.into()),
            String("IsTrue".into()),
            Boolean(true),
            String("IsNotFalse".into()),
            Boolean(false),
            EndCollection,
        ];

        assert_eq!(events.unwrap(), comparison);
    }

    #[test]
    fn bad_data() {
        let reader = File::open("./tests/data/xml_error.plist").unwrap();
        let streaming_parser = XmlReader::new(BufReader::new(reader));
        let events: Vec<_> = streaming_parser.collect();

        assert!(events.last().unwrap().is_err());
    }
}