// 所有权转移示例
fn main() {
    let s1 = String::from("hello");  // s1获得所有权
    let s2 = s1;                    // 所有权转移至s2
    // println!("{}", s1);         // 编译错误：s1不再有效
    println!("{}", s2);            // 正确：s2拥有数据
}

fn analyze_memory_safety() {
    let mut data = vec![1, 2, 3];

    let reference1 = &data[0];      // 不可变借用
    // let reference2 = &mut data[1]; // 编译错误：同时存在可变和不可变借用
    println!("{}", reference1);
}

// 显式生命周期标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 生命周期省略规则应用
fn first_word(s: &str) -> &str {  // 编译器推断生命周期
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

use std::sync::{Arc, Mutex};
use std::thread;

fn concurrent_counter() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);

        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

use std::sync::atomic::{AtomicUsize, Ordering};
use std::ptr;

struct LockFreeQueue<T> {
    head: AtomicUsize,
    tail: AtomicUsize,
    buffer: *mut Option<T>,
}

impl<T> LockFreeQueue<T> {
    pub fn new(capacity: usize) -> Self {
        let buffer = vec![None; capacity].as_mut_ptr() as *mut Option<T>;
        Self {
            head: AtomicUsize::new(0),
            tail: AtomicUsize::new(0),
            buffer,
        }
    }

    pub fn enqueue(&self, value: T) -> Result<(), T> {
        // CAS-based enqueue implementation
        // 详细实现省略...
        Ok(())
    }
}

use memmap2::Mmap;
use std::fs::File;
use std::io::{BufRead, BufReader};
use rayon::prelude::*;

pub struct LogAnalyzer {
    file_path: PathBuf,
    pattern: Regex,
}

impl LogAnalyzer {
    pub fn analyze(&self) -> Result<HashMap<String, usize>> {
        let file = File::open(&self.file_path)?;
        let mmap = unsafe { Mmap::map(&file)? };

        mmap.par_chunks(1024 * 1024)

            .flat_map(|chunk| {
                chunk.lines()
                    .filter_map(Result::ok)

                    .filter(|line| self.pattern.is_match(line))
            })
            .fold(

                || HashMap::new(),
                |mut acc, line| {
                    *acc.entry(line.to_string()).or_insert(0) += 1;
                    acc
                }
            )
            .reduce(

                || HashMap::new(),
                |mut a, b| {
                    for (k, v) in b {
                        *a.entry(k).or_insert(0) += v;
                    }
                    a
                }
            )
    }
}

#[derive(Debug)]
pub struct DistributedQueue {
    partitions: HashMap<u32, Partition>,
    coordinator: Arc<Coordinator>,
    storage: Arc<dyn StorageEngine>,
}

impl DistributedQueue {
    pub async fn produce(&self, topic: &str, message: Message) -> Result<ProduceResult> {
        let partition_id = self.coordinator.assign_partition(topic, &message.key).await?;
        let partition = self.partitions.get(&partition_id).ok_or(Error::PartitionNotFound)?;

        partition.append(message).await
    }

    pub async fn consume(&self, topic: &str, group: &str) -> Result<Vec<Message>> {
        let assignment = self.coordinator.get_assignment(topic, group).await?;
        let mut messages = Vec::new();

        for partition_id in assignment {
            if let Some(partition) = self.partitions.get(&partition_id) {
                messages.extend(partition.consume(group).await?);
            }
        }

        Ok(messages)
    }
}

[profile.release]
codegen-units = 1
lto = true
panic = "abort"
opt-level = 3
debug = false
strip = true

[build]
rustflags = ["-C", "target-cpu=native"]

use metrics::{counter, histogram};
use metrics_exporter_prometheus::PrometheusBuilder;

pub fn setup_metrics() -> Result<()> {
    let builder = PrometheusBuilder::new();
    builder.install()?;

    counter!("requests_total", "Total number of requests").increment(1);
    histogram!("request_duration_seconds", "Request duration in seconds")
        .record(0.234);

    Ok(())
}