temp2

Changelog.md

@@ -217,7 +217,6 @@
 [#439]: https://github.com/tafia/quick-xml/pull/439
 [#440]: https://github.com/tafia/quick-xml/pull/440
 
-
 ## 0.23.0 -- 2022-05-08
 
 - feat: add support for `i128` / `u128` in attributes or text/CDATA content

README.md

@@ -270,7 +270,6 @@ Note that despite not focusing on performance (there are several unnecessary cop
 Benchmarking is hard and the results depend on your input file and your machine.
 
 Here on my particular file, quick-xml is around **50 times faster** than [xml-rs](https://crates.io/crates/xml-rs) crate.
-_(measurements was done while this crate named quick-xml)_
 
 ```
 // quick-xml benches

src/de/mod.rs

@@ -225,7 +225,7 @@ use serde::de::{self, Deserialize, DeserializeOwned, Visitor};
 use std::borrow::Cow;
 #[cfg(feature = "overlapped-lists")]
 use std::collections::VecDeque;
-use std::io::BufRead;
+use std::io::{BufReader, Read};
 #[cfg(feature = "overlapped-lists")]
 use std::num::NonZeroUsize;
 
@@ -301,7 +301,7 @@ where
 /// as much as possible, use [`from_str`].
 pub fn from_reader<R, T>(reader: R) -> Result<T, DeError>
 where
-    R: BufRead,
+    R: Read,
     T: DeserializeOwned,
 {
     let mut de = Deserializer::from_reader(reader);
@@ -685,7 +685,7 @@ impl<'de> Deserializer<'de, SliceReader<'de>> {
 
 impl<'de, R> Deserializer<'de, IoReader<R>>
 where
-    R: BufRead,
+    R: Read,
 {
     /// Create new deserializer that will copy data from the specified reader
     /// into internal buffer. If you already have a string use [`Self::from_str`]
@@ -908,12 +908,12 @@ pub trait XmlRead<'i> {
 ///
 /// You cannot create it, it is created automatically when you call
 /// [`Deserializer::from_reader`]
-pub struct IoReader<R: BufRead> {
-    reader: Reader<R>,
+pub struct IoReader<R: Read> {
+    reader: Reader<BufReader<R>>,
     buf: Vec<u8>,
 }
 
-impl<'i, R: BufRead> XmlRead<'i> for IoReader<R> {
+impl<'i, R: Read> XmlRead<'i> for IoReader<R> {
     fn next(&mut self) -> Result<DeEvent<'static>, DeError> {
         let event = loop {
             let e = self.reader.read_event_into(&mut self.buf)?;

src/reader/buffered_reader.rs

@@ -2,7 +2,7 @@
 //! underlying byte stream.
 
 use std::fs::File;
-use std::io::{self, BufRead, BufReader};
+use std::io::{self, BufRead, BufReader, Read};
 use std::path::Path;
 
 use memchr;
@@ -223,6 +223,34 @@ impl<R: BufRead> Reader<R> {
     }
 }
 
+// #[cfg(feature = "encoding")]
+// impl<R: Read> Reader<BufReader<DecodeReaderBytes<R, Vec<u8>>>> {
+//     /// Creates an XML reader from a file path.
+//     pub fn from_read_impl<P: Read>(reader: P) -> Result<Self> {
+//         let decoder = DecodeReaderBytesBuilder::new()
+// 		.encoding(Some(UTF_8))
+// 		.bom_override(true)
+// 		.build(reader);
+
+//         let reader = Self {
+//             reader: BufReader::new(decoder),
+//             opened_buffer: Vec::new(),
+//             opened_starts: Vec::new(),
+//             tag_state: TagState::Init,
+//             expand_empty_elements: false,
+//             trim_text_start: false,
+//             trim_text_end: false,
+//             trim_markup_names_in_closing_tags: true,
+//             check_end_names: true,
+//             buf_position: 0,
+//             check_comments: false,
+//             encoding: EncodingRef::Implicit(UTF_8),
+//         };
+//         Ok(reader)
+//     }
+// }
+
+
 #[cfg(feature = "encoding")]
 impl Reader<BufReader<DecodeReaderBytes<File, Vec<u8>>>> {
     /// Creates an XML reader from a file path.
@@ -273,6 +301,51 @@ impl Reader<BufReader<File>> {
     }
 }
 
+#[cfg(not(feature = "encoding"))]
+impl<R: Read> Reader<BufReader<R>> {
+    /// Creates an XML reader from a file path.
+    pub fn from_reader(reader: R) -> Self {
+        Self {
+            reader: BufReader::new(reader),
+            opened_buffer: Vec::new(),
+            opened_starts: Vec::new(),
+            tag_state: TagState::Init,
+            expand_empty_elements: false,
+            trim_text_start: false,
+            trim_text_end: false,
+            trim_markup_names_in_closing_tags: true,
+            check_end_names: true,
+            buf_position: 0,
+            check_comments: false,
+        }
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl<R: Read> Reader<BufReader<DecodeReaderBytes<R, Vec<u8>>>> {
+    /// Creates an XML reader from a file path.
+    pub fn from_reader(reader: R) -> Self {
+        let decoder = DecodeReaderBytesBuilder::new()
+		.encoding(Some(UTF_8))
+		.bom_override(true)
+		.build(reader);
+        Self {
+            reader: BufReader::new(decoder),
+            opened_buffer: Vec::new(),
+            opened_starts: Vec::new(),
+            tag_state: TagState::Init,
+            expand_empty_elements: false,
+            trim_text_start: false,
+            trim_text_end: false,
+            trim_markup_names_in_closing_tags: true,
+            check_end_names: true,
+            buf_position: 0,
+            check_comments: false,
+            encoding: EncodingRef::Implicit(UTF_8),
+        }
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// Implementation of `XmlSource` for any `BufRead` reader using a user-given

src/reader/mod.rs

@@ -330,33 +330,11 @@ pub struct Reader<R> {
     encoding: EncodingRef,
 }
 
-/// Builder methods
-impl<R: Read> Reader<R> {
-    /// Creates a `Reader` that reads from a given reader.
-    pub fn from_reader(reader: R) -> Self {
-        Self {
-            reader,
-            opened_buffer: Vec::new(),
-            opened_starts: Vec::new(),
-            tag_state: TagState::Init,
-            expand_empty_elements: false,
-            trim_text_start: false,
-            trim_text_end: false,
-            trim_markup_names_in_closing_tags: true,
-            check_end_names: true,
-            buf_position: 0,
-            check_comments: false,
-
-            #[cfg(feature = "encoding")]
-            encoding: EncodingRef::Implicit(UTF_8),
-        }
-    }
-
-    configure_methods!();
-}
-
 /// Getters
 impl<R> Reader<R> {
+    // Builder methods
+    configure_methods!();
+
     /// Consumes `Reader` returning the underlying reader
     ///
     /// Can be used to compute line and column of a parsing error position

src/reader/ns_reader.rs

@@ -32,14 +32,16 @@ pub struct NsReader<R> {
 }
 
 /// Builder methods
-impl<R: Read> NsReader<R> {
+impl<R> NsReader<R> {
+    configure_methods!(reader);
+}
+
+impl<R: Read> NsReader<BufReader<R>> {
     /// Creates a `NsReader` that reads from a reader.
     #[inline]
     pub fn from_reader(reader: R) -> Self {
         Self::new(Reader::from_reader(reader))
     }
-
-    configure_methods!(reader);
 }
 
 /// Private methods
@@ -509,7 +511,8 @@ impl<R: BufRead> NsReader<R> {
 impl NsReader<BufReader<File>> {
     /// Creates an XML reader from a file path.
     pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
-        Ok(Self::new(Reader::from_file(path)?))
+        let file = File::open(path)?;
+        Ok(Self::from_reader(file))
     }
 }