// Rust编译器通过所有权系统防止内存错误
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1的所有权转移到s2，s1不再有效
    // println!("{}", s1); // 编译错误：value borrowed after move
}

// 深度分析所有权转移的编译器实现
#[derive(Debug)]
struct Data {
    value: Vec<u8>,
    metadata: String,
}

impl Data {
    fn new() -> Self {
        Data {
            value: vec![1, 2, 3, 4, 5],
            metadata: "sample".to_string(),
        }
    }
}

fn take_ownership(data: Data) -> usize {
    // data进入函数作用域，调用者失去所有权
    data.value.len()
} // data离开作用域，drop trait被自动调用

fn main() {
    let original = Data::new();
    let size = take_ownership(original);
    // println!("{:?}", original); // 编译错误：value used after move
}

// 简化的编译器内部所有权跟踪结构
struct OwnershipTracker {
    variable_scope: HashMap<VariableId, ScopeId>,
    value_owners: HashMap<ValueId, VariableId>,
    moved_values: HashSet<ValueId>,
    borrow_graph: BorrowGraph, // 借用关系图
}

impl OwnershipTracker {
    fn check_move_validity(&mut self, src: VariableId, dest: VariableId) -> Result<(), MoveError> {
        if self.moved_values.contains(&src) {
            return Err(MoveError::AlreadyMoved);
        }
        // 更新所有权关系
        self.moved_values.insert(src);
        self.value_owners.insert(dest_value, dest);
        Ok(())
    }
}

fn process_data(data: &mut Vec<i32>) {
    let reference = &data[0]; // 不可变借用开始
    // 一些不使用reference的代码
    println!("Processing data");
    // NLL使得reference在此处已结束生命周期
    data.push(42); // 可变借用允许 - 在NLL之前这会编译错误
}

// 复杂生命周期场景分析
struct ConnectionPool<'a> {
    connections: Vec<&'a mut Connection>,
    config: &'a Config,
}

impl<'a> ConnectionPool<'a> {
    fn borrow_connection(&mut self) -> Option<&'a mut Connection> {
        self.connections.pop()
    }

    fn return_connection(&mut self, conn: &'a mut Connection) {
        self.connections.push(conn);
    }
}

// 高阶trait边界中的生命周期
trait Service: for<'a> Fn(&'a Request) -> Response + Send + Sync {}
impl<T> Service for T where T: for<'a> Fn(&'a Request) -> Response + Send + Sync {}

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

struct Counter {
    value: AtomicUsize,
}

impl Counter {
    fn new() -> Self {
        Counter {
            value: AtomicUsize::new(0),
        }
    }

    fn increment(&self) {
        // 使用Acquire-Release内存顺序保证可见性
        self.value.fetch_add(1, Ordering::AcqRel);
    }

    fn get(&self) -> usize {
        self.value.load(Ordering::Acquire)
    }
}

fn concurrent_increment() {
    let counter = Arc::new(Counter::new());
    let mut handles = vec![];

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

        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                counter.increment();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    assert_eq!(counter.get(), 10000);
}

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

struct LockFreeStack<T> {
    head: AtomicPtr<Node<T>>,
}

struct Node<T> {
    value: T,
    next: *mut Node<T>,
}

impl<T> LockFreeStack<T> {
    fn new() -> Self {
        LockFreeStack {
            head: AtomicPtr::new(ptr::null_mut()),
        }
    }

    fn push(&self, value: T) {
        let new_node = Box::into_raw(Box::new(Node {
            value,
            next: ptr::null_mut(),
        }));

        loop {
            let current_head = self.head.load(Ordering::Acquire);
            unsafe {
                (*new_node).next = current_head;
            }

            if self.head.compare_exchange_weak(
                current_head, 
                new_node, 
                Ordering::Release, 
                Ordering::Relaxed
            ).is_ok() {
                break;
            }
        }
    }
}

// 迭代器与手写循环性能对比
fn iterator_vs_loop(bench_data: &[i32]) -> i32 {
    // 迭代器版本
    bench_data.iter()

        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * 2)
        .sum()
}

fn manual_loop(bench_data: &[i32]) -> i32 {
    // 手写循环版本
    let mut sum = 0;
    for &item in bench_data {
        if item % 2 == 0 {
            sum += item * 2;
        }
    }
    sum
}

// 两种实现生成相同的汇编代码，验证零成本抽象

use std::collections::HashMap;
use std::io::{BufRead, BufReader};
use std::fs::File;

#[derive(Debug)]
pub struct Config {
    values: HashMap<String, String>,
}

impl Config {
    pub fn from_file(path: &str) -> Result<Self, ConfigError> {
        let file = File::open(path)?;
        let reader = BufReader::new(file);
        let mut config = Config {
            values: HashMap::new(),
        };

        for line_result in reader.lines() {
            let line = line_result?;
            if let Some((key, value)) = Self::parse_line(&line) {
                // Rust的所有权系统确保字符串安全存储
                config.values.insert(key, value);
            }
        }

        Ok(config)
    }

    fn parse_line(line: &str) -> Option<(String, String)> {
        let mut parts = line.splitn(2, '=');
        let key = parts.next()?.trim();
        let value = parts.next()?.trim();

        if key.is_empty() || key.starts_with('#') {
            return None;
        }

        Some((key.to_string(), value.to_string()))
    }

    pub fn get(&self, key: &str) -> Option<&str> {

        self.values.get(key).map(|s| s.as_str())
    }
}

use actix_web::{web, App, HttpServer, Result};
use std::sync::Arc;
use tokio::sync::RwLock;

struct AppState {
    db_pool: Arc<DbConnectionPool>,
    cache: Arc<RwLock<Cache>>,
    config: Arc<Config>,
}

async fn get_user(
    state: web::Data<AppState>,
    user_id: web::Path<u64>,
) -> Result<web::Json<User>> {
    // Rust的异步安全保证：
    // - 引用在await点自动处理
    // - 状态安全共享
    let db = &state.db_pool;
    let user = db.get_user(*user_id).await?;

    // 安全并发缓存访问
    let mut cache = state.cache.write().await;
    cache.insert(user.id, user.clone());

    Ok(web::Json(user))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let state = web::Data::new(AppState {
        db_pool: Arc::new(DbConnectionPool::new()),
        cache: Arc::new(RwLock::new(Cache::new())),
        config: Arc::new(Config::load()?),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .route("/user/{id}", web::get().to(get_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

# Cargo.toml 配置示例
[package]
name = "high-performance-app"
version = "0.1.0"

[dependencies]
jemallocator = "0.3"

[features]
default = ["jemalloc"]
jemaLoc = ["jemallocator"]

# 在main.rs中
#[cfg(feature = "jemalloc")]
use jemallocator::Jemalloc;

#[cfg(feature = "jemalloc")]
#[global_allocator]
static GLOBAL: Jemalloc = Jemalloc;