rust--顶级高手系列--Structs

alloc::AllocError //主要用于在分配内存时，告知调用者分配失败的原因
//Rust 标准库中的全局分配器，它实现了 GlobalAlloc trait，是默认启用的分配器。
alloc::Global
alloc::Layout //描述内存块的大小和对齐方式，是分配内存时的关键参数。
//表示创建无效 Layout 时出现的错误，通常用于描述不合法的内存布局（如非 2 的幂对齐）。
alloc::LayoutError
//直接使用系统内存分配函数的分配器，默认情况下由 Rust 标准库提供。
alloc::System

 unsafe {
        let layout = Layout::from_size_align(1024, 8).unwrap();
        let ptr = Global.allocate(layout);

        match ptr {
            Ok(memory_block) => {
                let ptr = memory_block.as_non_null_ptr();

                println!("Memory allocated at: {:?}", ptr);

                // 使用完内存后别忘了释放
                unsafe {
                    Global.deallocate(ptr, layout);
                }

                println!("Memory deallocated");
            },
            Err(e) => {
                eprintln!("Failed to allocate memory: {:?}", e);
            }
        }
    }


// 创建一个内存布局，描述需要分配的内存块大小和对齐方式
let layout = Layout::from_size_align(1024, 8).unwrap();

println!("Size: {}", layout.size());
println!("Align: {}", layout.align());


match Layout::from_size_align(1024, 3) {
    Ok(layout) => {
        println!("Size: {}", layout.size());
        println!("Align: {}", layout.align());
    },
    //alloc::LayoutError 
    Err(e) => {
        eprintln!("Failed to create layout: {:?}", e);
    }
}

any::Demand
//TypeId 是一个在编译时确定的类型标识符。它是用来唯一识别不同类型的工具，通常在动态类型系统和反射中扮演重要角色。
any::TypeId

use std::any::{Any, TypeId};
//使用 Any 进行类型检查和转换
fn print_type_info<T: 'static + Any>(value: &T) {
    let type_id = TypeId::of::<T>();
    println!("TypeId: {:?}", type_id);

    if let Some(int) = value.downcast_ref::<i32>() {
        println!("The value is an i32: {}", int);
    } else if let Some(float) = value.downcast_ref::<f64>() {
        println!("The value is an f64: {}", float);
    } else {
        println!("Unknown type");
    }
}

fn main() {
    let value = 42_i32;
    print_type_info(&value);

    let value = 3.14_f64;
    print_type_info(&value);
}

//用于迭代固定大小数组的结构体。它允许你以一种安全和高效的方式迭代数组的元素，而不需要将数组转换为向量或切片。
array::IntoIter

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let iter = std::array::IntoIter::new(arr);

    for elem in iter {
        println!("{}", elem);
    }

    let arr = [1, 2, 3, 4, 5];
    let iter = arr.into_iter();

    for elem in iter {
        println!("{}", elem);
    }
}

//由于 Rust 的数组具有固定大小，而切片的大小在编译时不确定，当你尝试将一个切片转换为数组时，切片的大小必须与目标数组的大小匹配，否则会触发 TryFromSliceError。
array::TryFromSliceError

use std::convert::TryInto;

fn main() {
    let slice: &[i32] = &[1, 2, 3, 4];

    match slice.try_into() {
        Ok(arr) => {
            let arr: [i32; 4] = arr;
            println!("Array: {:?}", arr);
        },
        Err(e) => {
            eprintln!("Failed to convert slice into array: {:?}", e);
        }
    }

    let slice: &[i32] = &[1, 2, 3, 4, 5];
    match slice.try_into() as Result<[i32; 4], _> {
        Ok(arr) => println!("Array: {:?}", arr),
        Err(e) => eprintln!("Failed to convert slice into array: {:?}", e),
    }
}

ascii::EscapeDefault
async_iter::FromIter //从迭代器创建的异步迭代器。

• futures 库提供了异步编程的核心特性和基础结构 futures::future：用于定义和操作 futures（异步任务）。futures::stream：用于定义和操作 streams（异步数据流）。futures::executor：提供一个简单的执行器来运行异步任务。
• futures_util 是一个扩展库，它基于 futures 提供了一些工具和扩展方法，旨在简化和增强异步编程。它通常包含了一些便利方法（例如 join, select, try_join 等）和符合式组合方法（combinators）。
• tokio 基于 futures，结合了该库的基础特性，并扩展出自己的异步编程模型和工具。开发者可以在项目中同时使用 tokio 和 futures，它们互相兼容且互补。

use futures_util::stream::StreamExt;
#[tokio::test]
async fn test() {
    let data_stream = tokio_stream::iter(vec![1, 2, 3, 4, 5]);

    // 处理异步流的每个元素
    data_stream.for_each(|data| async move {
        println!("Received data: {}", data);
    }).await;
}

char::CharTryFromError

fn main() {
    use std::convert::TryFrom;

    let result = char::try_from(128); // 128 超出有效 Unicode 码点
    match result {
        Ok(c) => println!("Character: {}", c),
        Err(e) => println!("Error: {:?}", e),
    }
}

char::DecodeUtf16

 let utf16_data = vec![0xD834, 0xDD1E]; // UTF-16 编码的 🎞️ (U+1F39E)
    let decoded: String = char::decode_utf16(utf16_data.into_iter())
        .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))
        .collect();
    println!("Decoded string: {}", decoded);

char::DecodeUtf16Error
char::EscapeDebug
char::EscapeDefault
char::EscapeUnicode
char::ParseCharError
char::ToLowercase
char::ToUppercase
char::TryFromCharError

task::Context
task::RawWaker
task::RawWakerVTable
task::Waker

thread::AccessError
thread::Builder

use std::thread;

fn main() {
    let builder = thread::Builder::new()
        .name("worker-thread".into())
        .stack_size(4 * 1024 * 1024); // 设置栈大小为 4MB

    let handle = builder.spawn(|| {
        println!("Hello from the thread!");
        // ... 线程代码 ...
    }).expect("Failed to create thread");

    handle.join().expect("Thread panicked");
}

thread::JoinHandle //是用来等待线程结束并获取其返回结果的句柄。
//LocalKey 类型表示一个线程本地存储的键，通常通过 thread_local! 宏创建。
thread::LocalKey
thread::Scope
thread::ScopedJoinHandle
thread::Thread
thread::ThreadId

time::Duration //表示一段时间，具有纳秒精度。

use std::time::Duration;

fn main() {
    let sec = Duration::from_secs(5);
    let milli = Duration::from_millis(500);
    let combined = sec + milli;

    println!("Seconds: {:?}", sec);
    println!("Milliseconds: {:?}", milli);
    println!("Combined: {:?}", combined);
     let start = Instant::now();
    // 模拟一些耗时操作，例如休眠两秒
    thread::sleep(std::time::Duration::from_secs(2));
    //elapsed 方法用于测量当前时间与 Instant 实例之间的时间间隔。
    let elapsed = start.elapsed();
    println!("Elapsed time: {:?}", elapsed);
 
    let start = Instant::now();
    // 模拟一些耗时操作，例如休眠一秒
    std::thread::sleep(Duration::from_secs(1));
    let end = Instant::now();
    //duration_since 方法用于计算从另一个 Instant 实例到当前 Instant 实例之间的时间间隔。
    let duration = end.duration_since(start);
    println!("Duration since start: {:?}", duration);
}

time::Instant //Instant 表示一个具体时间点，通常用于实现高精度时间测量
//SystemTime 表示系统时间，可以表示过去或将来的某个时间点。它依赖于系统时钟，适合用于日志记录、时间戳等绝对时间相关的操作。
time::SystemTime
time::SystemTimeError
time::TryFromFloatSecsError

vec::Drain //是一个迭代器，能有效地从 Vec 中移除连续的一段元素，并返回这些被移除的元素
//DrainFilter 是一个迭代器，能根据给定的闭包过滤 Vec 中的元素，并移除符合条件的元素，返回这些被移除的元素。
vec::DrainFilter
//IntoIter 是一个迭代器，能将 Vec 转换为一个拥有其所有元素的迭代器。
vec::IntoIter
//Splice 是一个迭代器，能在 Vec 中插入新元素，同时移除原有的元素。
vec::Splice

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];
//vec.splice(1..4, vec![6, 7, 8])：从 vec 中移除索引为 1 到 3 的元素，并插入 6、7 和 8。返回被移除的元素。
    let replaced: Vec<_> = vec.splice(1..4, vec![6, 7, 8]).collect();
    println!("Replaced elements: {:?}", replaced);
    println!("Updated vec: {:?}", vec);
}

vec::Vec