如何在Rust中使用quick-xml库高效处理XML？

use quick_xml::events::Event;
use quick_xml::Reader;

fn parse_example_xml(xml_data: &str) -> Result<String, Box<dyn std::error::Error>> {
    let mut reader = Reader::from_str(xml_data);
    reader.trim_text(true); // 自动去除文本两边的空白

    let mut buf = Vec::new();
    let mut extracted_text = String::new();

    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Start(e)) => {
                // 假设我们关心 <item> 标签
                if e.name().as_ref() == b"item" {
                    // 找到 <item> 标签后，我们可以继续读取其内部的文本
                    // 这里只是一个简化示例，实际可能需要一个状态机来处理嵌套结构
                    // 为了演示，我们直接假设下一个事件就是文本
                    match reader.read_event_into(&mut buf) {
                        Ok(Event::Text(t)) => {
                            extracted_text = t.unescape()?.to_string();
                            break; // 找到了，就退出循环
                        },
                        Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                        _ => (), // 其他事件忽略
                    }
                }
            },
            Ok(Event::Eof) => break, // 文件结束
            Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
            _ => (), // 其他事件，比如End、Empty等，我们暂时不关心
        }
        buf.clear(); // 清空缓冲区，为下一次读取做准备
    }
    Ok(extracted_text)
}

// 实际使用：
// let xml = "<root><item>Hello, quick-xml!</item></root>";
// if let Ok(text) = parse_example_xml(xml) {
//     println!("Extracted: {}", text);
// }

use quick_xml::events::Event;
use quick_xml::Reader;

struct Book {
    title: String,
    author: String,
}

fn parse_books(xml_data: &str) -> Result<Vec<Book>, Box<dyn std::error::Error>> {
    let mut reader = Reader::from_str(xml_data);
    reader.trim_text(true); // 自动去除文本两边的空白

    let mut buf = Vec::new();
    let mut books = Vec::new();
    let mut current_book = Book { title: String::new(), author: String::new() };
    let mut in_title = false;
    let mut in_author = false;

    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Start(e)) => {
                match e.name().as_ref() {
                    b"book" => {
                        current_book = Book { title: String::new(), author: String::new() };
                    },
                    b"title" => in_title = true,
                    b"author" => in_author = true,
                    _ => (),
                }
            },
            Ok(Event::Text(e)) => {
                if in_title {
                    current_book.title = e.unescape()?.to_string();
                } else if in_author {
                    current_book.author = e.unescape()?.to_string();
                }
            },
            Ok(Event::End(e)) => {
                match e.name().as_ref() {
                    b"book" => {
                        books.push(current_book);
                    },
                    b"title" => in_title = false,
                    b"author" => in_author = false,
                    _ => (),
                }
            },
            Ok(Event::Eof) => break,
            Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
            _ => (),
        }
        buf.clear();
    }
    Ok(books)
}

use quick_xml::events::{BytesEnd, BytesStart, Event};
use quick_xml::Reader;
use quick_xml::Writer;
use std::io::Cursor;

fn transform_xml(input_xml: &str) -> Result<String, Box<dyn std::error::Error>> {
    let mut reader = Reader::from_str(input_xml);
    reader.trim_text(true);

    let mut writer = Writer::new(Cursor::new(Vec::new()));
    let mut buf = Vec::new();

    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Start(e)) => {
                // 假设我们想把所有的 <old_tag> 变成 <new_tag>
                if e.name().as_ref() == b"old_tag" {
                    writer.write_event(Event::Start(BytesStart::new("new_tag")))?;
                } else {
                    writer.write_event(Event::Start(e.to_owned()))?; // 写入原始事件
                }
            },
            Ok(Event::End(e)) => {
                if e.name().as_ref() == b"old_tag" {
                    writer.write_event(Event::End(BytesEnd::new("new_tag")))?;
                } else {
                    writer.write_event(Event::End(e.to_owned()))?;
                }
            },
            Ok(Event::Text(e)) => {
                // 假设我们想修改某个文本内容
                if reader.buffer_position() > 0 && input_xml[..reader.buffer_position()].contains("<item>") { // 粗略判断是否在item标签内
                    let text = e.unescape()?;
                    if text == "Hello" {
                        writer.write_event(Event::Text(quick_xml::events::BytesText::new("Greetings")))?;
                    } else {
                        writer.write_event(Event::Text(e.to_owned()))?;
                    }
                } else {
                    writer.write_event(Event::Text(e.to_owned()))?;
                }
            },
            Ok(Event::Eof) => break,
            Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
            event => writer.write_event(event.to_owned())?, // 写入其他所有事件类型
        }
        buf.clear();
    }

    let result = writer.into_inner().into_inner();
    Ok(String::from_utf8(result)?)
}

// 示例使用：
// let input = "<root><old_tag><item>Hello</item></old_tag><another_tag>World</another_tag></root>";
// if let Ok(output) = transform_xml(input) {
//     println!("Transformed: {}", output);
// }