BytesStart::to_borrowed renamed to BytesStart::borrow, the same method added to all events

Author: Mingun

Changelog.md

@@ -25,6 +25,8 @@
 - [#395]: Add support for XML Schema `xs:list`
 - [#324]: `Reader::from_str` / `Deserializer::from_str` / `from_str` now ignore
   the XML declared encoding and always use UTF-8
+- [#416]: Add `borrow()` methods in all event structs which allows to get
+  a borrowed version of any event
 
 ### Bug Fixes
 
@@ -108,6 +110,9 @@
   |`read_to_end_unbuffered` |`read_to_end`
 - [#412]: Change `read_to_end*` and `read_text_into` to accept `QName` instead of `AsRef<[u8]>`
 
+- [#416]: `BytesStart::to_borrowed` renamed to `BytesStart::borrow`, the same method
+  added to all events
+
 ### New Tests
 
 - [#9]: Added tests for incorrect nested tags in input
@@ -131,6 +136,7 @@
 [#403]: https://github.com/tafia/quick-xml/pull/403
 [#407]: https://github.com/tafia/quick-xml/pull/407
 [#412]: https://github.com/tafia/quick-xml/pull/412
+[#416]: https://github.com/tafia/quick-xml/pull/416
 
 ## 0.23.0 -- 2022-05-08
 

src/events/mod.rs

@@ -75,6 +75,14 @@ impl<'a> BytesStartText<'a> {
         self.content.into_inner()
     }
 
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> BytesStartText {
+        BytesStartText {
+            content: self.content.borrow(),
+        }
+    }
+
     /// Decodes bytes of event, stripping byte order mark (BOM) if it is presented
     /// in the event.
     ///
@@ -195,15 +203,15 @@ impl<'a> BytesStart<'a> {
     /// # fn example(&self) -> Result<(), Error> {
     /// # let mut writer = Writer::new(Vec::new());
     ///
-    /// writer.write_event(Event::Start(self.attrs.to_borrowed()))?;
+    /// writer.write_event(Event::Start(self.attrs.borrow()))?;
     /// // ...
     /// writer.write_event(Event::End(self.attrs.to_end()))?;
     /// # Ok(())
     /// # }}
     /// ```
     ///
     /// [`to_end`]: Self::to_end
-    pub fn to_borrowed(&self) -> BytesStart {
+    pub fn borrow(&self) -> BytesStart {
         BytesStart::borrowed(&self.buf, self.name_len)
     }
 
@@ -343,13 +351,13 @@ impl<'a> Deref for BytesStart<'a> {
 /// [W3C XML 1.1 Prolog and Document Type Declaration](http://w3.org/TR/xml11/#sec-prolog-dtd)
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct BytesDecl<'a> {
-    element: BytesStart<'a>,
+    content: BytesStart<'a>,
 }
 
 impl<'a> BytesDecl<'a> {
     /// Creates a `BytesDecl` from a `BytesStart`
-    pub fn from_start(start: BytesStart<'a>) -> BytesDecl<'a> {
-        BytesDecl { element: start }
+    pub fn from_start(start: BytesStart<'a>) -> Self {
+        Self { content: start }
     }
 
     /// Gets xml version, excluding quotes (`'` or `"`).
@@ -407,7 +415,7 @@ impl<'a> BytesDecl<'a> {
     /// [grammar]: https://www.w3.org/TR/xml11/#NT-XMLDecl
     pub fn version(&self) -> Result<Cow<[u8]>> {
         // The version *must* be the first thing in the declaration.
-        match self.element.attributes().with_checks(false).next() {
+        match self.content.attributes().with_checks(false).next() {
             Some(Ok(a)) if a.key.as_ref() == b"version" => Ok(a.value),
             // first attribute was not "version"
             Some(Ok(a)) => {
@@ -457,7 +465,7 @@ impl<'a> BytesDecl<'a> {
     ///
     /// [grammar]: https://www.w3.org/TR/xml11/#NT-XMLDecl
     pub fn encoding(&self) -> Option<Result<Cow<[u8]>>> {
-        self.element
+        self.content
             .try_get_attribute("encoding")
             .map(|a| a.map(|a| a.value))
             .transpose()
@@ -499,7 +507,7 @@ impl<'a> BytesDecl<'a> {
     ///
     /// [grammar]: https://www.w3.org/TR/xml11/#NT-XMLDecl
     pub fn standalone(&self) -> Option<Result<Cow<[u8]>>> {
-        self.element
+        self.content
             .try_get_attribute("standalone")
             .map(|a| a.map(|a| a.value))
             .transpose()
@@ -548,7 +556,7 @@ impl<'a> BytesDecl<'a> {
         buf.push(b'"');
 
         BytesDecl {
-            element: BytesStart::owned(buf, 3),
+            content: BytesStart::owned(buf, 3),
         }
     }
 
@@ -563,7 +571,15 @@ impl<'a> BytesDecl<'a> {
     /// Converts the event into an owned event.
     pub fn into_owned(self) -> BytesDecl<'static> {
         BytesDecl {
-            element: self.element.into_owned(),
+            content: self.content.into_owned(),
+        }
+    }
+
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> BytesDecl {
+        BytesDecl {
+            content: self.content.borrow(),
         }
     }
 }
@@ -572,7 +588,7 @@ impl<'a> Deref for BytesDecl<'a> {
     type Target = [u8];
 
     fn deref(&self) -> &[u8] {
-        &*self.element
+        &*self.content
     }
 }
 
@@ -608,6 +624,14 @@ impl<'a> BytesEnd<'a> {
         }
     }
 
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> BytesEnd {
+        BytesEnd {
+            name: Cow::Borrowed(&self.name),
+        }
+    }
+
     /// Gets the undecoded raw tag name, as present in the input stream.
     #[inline]
     pub fn name(&self) -> QName {
@@ -699,6 +723,14 @@ impl<'a> BytesText<'a> {
         self.content
     }
 
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> BytesText {
+        BytesText {
+            content: Cow::Borrowed(&self.content),
+        }
+    }
+
     /// Returns unescaped version of the text content, that can be written
     /// as CDATA in XML
     #[cfg(feature = "serialize")]
@@ -853,6 +885,14 @@ impl<'a> BytesCData<'a> {
         self.content
     }
 
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> BytesCData {
+        BytesCData {
+            content: Cow::Borrowed(&self.content),
+        }
+    }
+
     /// Converts this CDATA content to an escaped version, that can be written
     /// as an usual text in XML.
     ///
@@ -1015,6 +1055,24 @@ impl<'a> Event<'a> {
             Event::Eof => Event::Eof,
         }
     }
+
+    /// Converts the event into a borrowed event.
+    #[inline]
+    pub fn borrow(&self) -> Event {
+        match self {
+            Event::StartText(e) => Event::StartText(e.borrow()),
+            Event::Start(e) => Event::Start(e.borrow()),
+            Event::End(e) => Event::End(e.borrow()),
+            Event::Empty(e) => Event::Empty(e.borrow()),
+            Event::Text(e) => Event::Text(e.borrow()),
+            Event::Comment(e) => Event::Comment(e.borrow()),
+            Event::CData(e) => Event::CData(e.borrow()),
+            Event::Decl(e) => Event::Decl(e.borrow()),
+            Event::PI(e) => Event::PI(e.borrow()),
+            Event::DocType(e) => Event::DocType(e.borrow()),
+            Event::Eof => Event::Eof,
+        }
+    }
 }
 
 impl<'a> Deref for Event<'a> {

src/se/var.rs

@@ -154,7 +154,7 @@ where
         } else {
             self.parent
                 .writer
-                .write_event(Event::Start(self.attrs.to_borrowed()))?;
+                .write_event(Event::Start(self.attrs.borrow()))?;
             self.parent.writer.write(&self.children)?;
             self.parent
                 .writer

src/writer.rs

@@ -256,7 +256,7 @@ impl<'a, W: Write> ElementWriter<'a, W> {
     /// Write some text inside the current element.
     pub fn write_text_content(self, text: BytesText) -> Result<&'a mut Writer<W>> {
         self.writer
-            .write_event(Event::Start(self.start_tag.to_borrowed()))?;
+            .write_event(Event::Start(self.start_tag.borrow()))?;
         self.writer.write_event(Event::Text(text))?;
         self.writer
             .write_event(Event::End(self.start_tag.to_end()))?;
@@ -266,7 +266,7 @@ impl<'a, W: Write> ElementWriter<'a, W> {
     /// Write a CData event `<![CDATA[...]]>` inside the current element.
     pub fn write_cdata_content(self, text: BytesCData) -> Result<&'a mut Writer<W>> {
         self.writer
-            .write_event(Event::Start(self.start_tag.to_borrowed()))?;
+            .write_event(Event::Start(self.start_tag.borrow()))?;
         self.writer.write_event(Event::CData(text))?;
         self.writer
             .write_event(Event::End(self.start_tag.to_end()))?;
@@ -276,7 +276,7 @@ impl<'a, W: Write> ElementWriter<'a, W> {
     /// Write a processing instruction `<?...?>` inside the current element.
     pub fn write_pi_content(self, text: BytesText) -> Result<&'a mut Writer<W>> {
         self.writer
-            .write_event(Event::Start(self.start_tag.to_borrowed()))?;
+            .write_event(Event::Start(self.start_tag.borrow()))?;
         self.writer.write_event(Event::PI(text))?;
         self.writer
             .write_event(Event::End(self.start_tag.to_end()))?;
@@ -295,7 +295,7 @@ impl<'a, W: Write> ElementWriter<'a, W> {
         F: Fn(&mut Writer<W>) -> Result<()>,
     {
         self.writer
-            .write_event(Event::Start(self.start_tag.to_borrowed()))?;
+            .write_event(Event::Start(self.start_tag.borrow()))?;
         closure(&mut self.writer)?;
         self.writer
             .write_event(Event::End(self.start_tag.to_end()))?;