let m = 5;
let mut n = &m;
	//将引用赋值给可变变量
let n = &mut m;
	//获取可变引用赋值给变量，这里会报错，因为`m`是不可变
	//变量，不允许通过其获取可变引用

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str{
	if x.len() > y.len(){
		x
	}else{
		y
	}
}

impl<'a> stct<'a>{
	fn other_str(&self, &str1) -> &str{
		str1
	}
}
// 检查完规则之后，所有引用均有注解，但是
// 函数体中的生命周期和签名中不一致

struct ImportantExcerpt<'a>{
	part: &'a str,
}

impl<'a> ImportantExcerpt<'a>{
	fn (&self){
	}
}

fn new(args: &[String]) -> Result<Config, &'a str>{}
fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str>{}

struct Context<'s>(&'s str);
struct Parser<'c, 's: 'c>{
	//`'s: 'c`声明一个不短于`'c`的生命周期`'s`
	context: &'c Context<'s>;
}
impl<'c, 's: 'c> Parser<'c, 's: 'c>{
	fn parse(&self) -> Result<(), &'s str>{
		//根据生命周期省略规则，若`'s`省略，则赋予`&self`的
		//生命周期
		//使用生命周期子类型语法，指定（要求）`&str`生命周期
		//长于`&Context`
		Err(&self.context.0[1..]
		//这里没有考虑字符串切片的有效性，如果这个切片不是
		//有效的unicode字符串（utf8字节序列），会panic
	}
}
fn parse_context(context: Context) -> Result<(), &str>{
	//方法获取`context`的所有权
	Parser{ context: &Context }.parse()
	//`&Context`的生命周期只有整个函数内
	//函数体中的返回值是`context.0[1..]`，为保证返回值有效，
	//其生命周期必须长于整个函数
	//返回值中的`&str`类型的生命周期是`'s`，长于context`'c`
	//满足返回值的生命周期长于函数的要求，能编译通过
}

struct Ref<'a, T: 'a> { &'a T };
	//为`T`增加生命周期bound，指定`T`引用的生命周期不短于
	//`'a`，保证结构体成员有效
struct StaticRef<T: 'static> { &'static T };
	//限制`T`为只拥有`'static`生命周期的引用或没有引用的类型

trait Red {}
struct Ball<'a> {
	diameter: &'a i32,
}
impl<'a> Red for Ball<'a> {}
fn main(){
	let num = 5;
	let obj = Box::new(Ball {diameter: &num}) as Box<Red>;
}

let mut num = 5;
let r1 = &num as *const i32;
let r2 = &num as *mut i32;
	//`as`将不可变引用和可变引用强转为对应的裸指针类型
	//同时创建`num`的可变裸指针和不可变裸指针
	//创建裸指针是安全的
unsafe{
	println!("r1 is: {}", *r1);
	println!("r2 is: {}", *r2);
		//解引用裸指针是不安全的，需要放在`unsafe`块中
}

let address = 0x012345usize;
	//创建任意地址
let r = address  as *const i32;
	//创建指向任意内存地址的裸指针

unsafe fn dangerous() {}
	//`unsafe`关键字表示此函数为不安全函数，含有内存不安全
	//内容，需要程序员自身保证其内存安全
	//但是，包含不安全代码的函数不意味着整个函数都需要标记为
	//不安全，相反的，将不安全代码封装进安全函数是常用的

	//不安全函数体也是`unsafe`块，在其中进行不安全操作时，
	//不需要包裹于`unsafe`块

unsafe{
	dangerous();
	//调用不安全函数也需要在`unsafe`块中，表示调用者确认此
	//“不安全”函数在此上下文中是*内存安全*
}

let mut v = vec![1, 2, 3, 4, 5, 6];
let r = &mut v[..];
let (a, b)  r.split_at_mut(3);
	//以index=3分隔为两个列表引用（左开右闭）

assert_eq!(a, &mut [1, 2, 3]);
assert_eq!(b, &mut [4, 5, 6]);

use std::slice;

fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
	//这里根据生命周期省略规则省略了生命周期注解

	//在所有权里就有提到，这里不也是可变引用吗，为啥这样
	//还可以通过编译，是对方法中的`self`有特殊的处理吗

	let len = slice.len();
	let ptr = slice.as_mut_ptr();
		//`as_mut_ptr`返回`*mut T`可变裸指针
	
	assert!(mid <= len);
	
	unsafe{
		(slice::from_raw_parts_mut(ptr, mid),
			//`from_raw_parts_mut`根据裸指针和长度两个参数
			//创建slice，其是不安全的，因为其参数是一个
			//裸指针，无法保证内存安全，另外长度也不总是有效
		slice::from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
			//`offset`同样是不安全的，其参数地址偏移量无法
			//保证始终有效
	}
}

extern "C" {
	//`"C"`定义了外部函数所使用的ABI
	fn abs(input: i32) -> i32;
	//希望调用的其他语言中的（外部）函数签名
}
fn main(){
	unsafe{
		println!("absolute value of -3 according to C: {}", abs(-3));
	}
}

#[no_mangle]
	//告诉Rust编译器不要mangle此函数名称
pub extern "C" fn call_from_c(){
	//此函数编译器为动态库并从C语言中链接，就可在C代码中访问
	println!("just called a Rust function from C!");
}

static HELLO_WORLD: &str = "Hello, world!";
	//静态变量（不可变）
fn main(){
	println!("name is: {}", HELLO_WORLD);
}

static mut COUNTER： u32 = 0;
	//可变静态变量

fn add_to_count(inc: u32){
	unsafe {
		COUNTER += inc;
		//修改可变静态变量
	}
}

fn main(){
	add_to_count(3);

	unsafe{
		println!("COUNTER: {}", COUNTER);
		//访问可变静态变量
	}
}

unsafe trait Foo{
}
unsafe impl Foo for i32{
}

let Some(x) = some_optiona_value;
	//`Some(x)`是refutable模式，若`some_optional_value`为
	//None，则此时无法成功匹配，此语句可能无法正常工作
if let x = 5 {
	//`x`是inrefutable模式，对所有可能值都可以匹配，此语句
	//无意义
	println!("{}", x);
}

let x = Some(5);
let y = 10;

match x{
	Some(50) => println!("got 50"),
		//`Some(50)`这个模式规定了“值”
	Some(y) => println!("matched, y = {:?}", y),
		//match表达式作用域中的`y`会覆盖周围环境的`y`
	_ => println!("default case, x = {:?}", x),
}
println!("at the end: x = {:?}, y = {:?}", x, y);

fn main(){
	let favorite_color: Option<&str> = None;
	let is_tuesday = false;
	let age: Result<u8, _> = "34".parse();

	if let Some(color) = favorite_color{
		//模式匹配
		//注意这里是`=`而不是一般值比较`==`
		//`while`同
		println!("favorite color is {}", color};
	}else if is_tuesday{
		//普通`if`条件语句
		println!("Tuesday is green day!");
	}else if let Ok(age) = age{
		//`age`变量覆盖原变量
		//此时`age`是`u8`类型
		if age > 30 {
			//因此此条件不能提出，因为两个`age`变量不同，
			//不能共存在同一条语句中
			println!("Using purple as the background color");
		}else{
			println!("Using orange as the background color");
		}
	}else{
		println!("Using blue as the background color");
	}
}

fn main(){
	let mut stack = Vec::new();
	stack.push(1);
	stack.push(2);
	stack.push(3);
	while let Some(top) = stack.pop(){
		println!("{}", top);
	}
}

fn main(){
	let v = vec!['a', 'b', 'c'];
	for (index, value) in v.iter().enumerate(){
		//解构tuple
		println!("{} is at index {}", value, index);
	}
}

let PARTTERN = EXPRESSION;
	//这样就和`if let`模式匹配中`=`一致
	//应该可以把`=`看作是模式匹配的符号

let x = 5;
	//这里`x`是一个模式“变量”
let (x, y, z) = (1, 2, 4);
	//`(x, y, z)`是模式“3元元组“
	//解构元组

fn foo(x: i32){
	//`x`表示模式“变量”
}
fn print_coordinates(&(x, y): &(i32, i32)){
	//这里`(x, y)`是模式“元组”
	//但是这里处于函数变量类型的要求，有点像元组结构体
	//调用时使用元组即可
	println!("Current location: ({}, {})", x, y);
}

let x = 1;
match x {
	1 => println!("one"),
		//`1`是模式“字面值”
	2 | 3 => println!("two or three"),
		//`|`分隔，匹配多个模式
	5...10 => println!("through 5 to 10"),
		//`...`表示匹配一个**闭区间**范围的值
		//这个语法只能用于数字或者是`char`值，因为编译器会
		//检查范围不为空，而只有数字、`char`值rust可以判断
	_ => println!("anything"),
}

let x = 'c';
match x {
	'a'...'j' => println!("early ASCII letter"),
	'k'...'z' => println!("late ASCII letter"),
	_ => println!("something else"),
}

let (x, _, z) = (1, 2, 4);
	//`_`忽略模式中各一个值
let (x, .., z) = (1, 2, 3, 4);
	//`..`忽略模式中多个值

struct Point{
	x: i32,
	y: i32,
}

fn main(){

	let p = Point{x: 0, y: 7};
	let Point{x: a, y: b} = p;
		//`Point{x: a, y: b}`是模式”Point结构体“
		//解构结构体

	let p = Point{x: 0, y: 7};
	let Point{x, y} = p;
		//模式匹配解构结构体简写
		//只要列出结构体字段，模式创建相同名称的变量

	let p = Point{x: 0, y: 7};
	match p {
		Point {x, y: 0} => println!("on the x axis at {}", x),
		Point {x: 0, y} => println!("on the y axis at {}", y),
		Point {x, y} => println!("on neither axis: ({}, {})", x, y),
			//这里没有`_`通配符，因为`Point {x, y}`模式已经
			//是irrefutable，不需要
	}
}

enum Message{
	Quit,
	Move{x: i32, y:i32},
	Write(String),
	ChangeColor(i32, i32, i32),
}
fn main(){

	let msg = Message::ChangeColor(0, 160, 255);

	let p = match msg{
		//这里`match`返回值必须类型完全相同
		Message::Move{x, y} if x == 0 => (x, y),
			//对于`Message`中的匿名结构体类型的成员，匿名
			//结构体没有枚举类型外的定义、名称，无法、也
			//不应该直接获取结构体
		Message::Write(ref str) => {
			//`Message::Write`不是`Message`的一个枚举成员
			//必须`Message::Write(str)`才是（能够匹配）
			println!("write {}", str);
			(1,1)
		},
		Message::ChangeColor(..) => (1,0),
			//类似的，需要使用`..`忽略值，仅`ChangeColor`
			//不是`Message`成员
		_ => {
			println!("quit");
			(0,0)
		},
	};
}

let num = Some(4);
let y = 5;
match num{
	Some(x) if x < y => println!("'less than y: {}", x),
	Some(x) => println!("{}", x),
	None => (),
}

let x = 4;
let y = false;
match x {
	4 | 5 | 6 if y => println!("yes"),
		//`4 | 5 | 6`整体作为一个模式，match guard作用于
		//模式整体，而不是单独的`6`
	_ => println!("no"),
}

enum Message{
	Hello { id: i32},
}

let msg = Message::Hello { id: 5 };
match msg{
	Message::Hello{ id: id_variable @ 3...7 } => {
		//匹配结构体模式（值绑定`id_variable`）&&值在`3...7`范围
		println!("Found an id in range: {}", id_variable)
	},
	Message::Hello{ id: 10...12 } => {
		//此分支模式指定了值的范围，但是没有绑定值给变量`id`
		//结构体匹配简略写法不能应用与此
		println!("Found an id in another range")
	}
	Message::Hello{ id } => {
		//此分支结构体匹配简略写法，值绑定于`id`
		println!("Found some other id: {}", id)
	},
}

let closures = |param1, param2|{
	...
	expression
}

fn  add_one_v1   {x: u32} -> u32 { x + 1 };
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1;
	//闭包体只有一行可以省略`{}`

let example_closure = |x| x;
let s = example_closure(String::from("hello"));
	//此时已经锁定闭包参数、返回值类型
let n = example_closure(5);
	//尝试使用`i32`类型调用闭包会报错

struct Cacher<T>
	where T: Fn(u32) -> u32{
		//`T`的类型中包括`Fn`、参数、返回值三个限定
	calculation: T,
	value: Option<u32>,
}

fn add_one(x: i32) -> i32{
	x + 1
}
fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32{
	//`f`是`fn`函数指针类型
	f(arg) + f(arg)
}
fn main(){
	let answer = do_twice(add_one, 5);
	println!("the anwser is: {}", anwser);
}

let list_of_numbers = vec![1, 2, 3];
let list_of_Strings: Vec<String> = list_of_numbers
	.iter()
	.map(|i| i.to_string())
		//闭包作为参数传递
	.collect();

let list_of_strings: Vec<String> = list_of_numbers
	.iter()
	.map(ToString::to_string)
		//函数作为参数传递
		//使用了完全限定语法，因为存在多个`to_string`函数
		//标准库为所有实现了`Display`的类型实现了此trait
	.collect();

fn main(){
	let x = vec![1, 2, 3]
	let equal_to_x = move |z| z == x;
	println!("can't use x here: {:?}", x);
		//此时`x`的所有权已经转移进闭包，不能在闭包外使用
	let y = vec![1, 2, 3];
	assert!(equal_to_x(y));

fn return_closure() -> Box<Fn(i32) -> i32>{
	//trait对象作为返回值
	Box::new(|x| x + 1)
}

trait Iterator{
	type Item;
		//定义`Iterator`的关联类型
	fn next(&mut self) -> Option<Self::Item);
		//参数是`&mut self`，要求迭代器是`mut`类型
		//`next`方法改变了迭代器中用来记录序列位置的状态
	//methods with default implementation elided
}

#[test]
fn iterator_demostration(){
	let v1 = vec![1, 2, 3];
	let mut v_iter = v1.iter();
		//注意`v_iter`声明为`mut`
		//使用`for`循环时无需使`v1_iter`可变，`for`会获取其
		//所有权并在后台使其可变

	assert_eq!(v1_iter.next(), Some(&1));
	assert_eq!(v1_iter.next(), Some(&2));
	assert_eq!(v1_iter.next(), Some(&3));
		//真的很难理解，rust中&integer是怎么比较的
	assert_eq!(v1_iter.nett(), None));
}

#[test]
fn iterator_sum(){
	let v1 = vec![1, 2, 3];
	let v1_iter = v1.iter();

	let total:i32 = v1_iter.sum();
		//`sum`获取迭代器所有权，`v1_iter`不能继续使用
	assert_eq!(total, 6);

let v1:Vec<i32> = vec![1, 2, 3];
v1.iter().map(|x| x + 1);
	//这里因为没有调用消费适配器，其实没有做事
let v2:Vec<_> =  v1.iter().map(|x| x + 1).collect();
assert_eq!(v2, vec![2, 3, 4])

#[derive(PartialEq, Debug)]
struct Shoe{
	size: u32,
	style: String,
}

fn shoes_in_my_size(shoes: Vec<Shoe>, show_size: u32) -> Vec<Shoe>{
	shoes.into_iter()
			//获取vector所有权的迭代器
		.filter(|s| s.size == show_size)
			//这里使用闭包获取外部环境变量
		.collect()
}

#[test]
fn filter_by_size(){
	let shoes = vec![
		Shoe{size: 10, style: String::from("sneaker")},
		Shoe{size: 13, style: String::from("sandal")},
		Shoe{size: 10, style: String::from("boot")},
	];

	let in_my_size = shoes_in_my_size(shoes, 10);

	assert_eq!(
		in_my_size,
		vec![
			Shoe{size: 10, style: String::from("sneaker")},
			Shoe{size: 10, style: String::from("boot")},
		]
	);
}

struct Counter{
	count: i32,
}
impl Counter{
	fn new() -> Counter{
		Counter{count: 0}
	}
}

impl Iterator for Counter{
	type Item = u32;
		//迭代器将返回`u32`值集合
	
	fn next(&mut self) -> Option<Self::Item>{
		self.count += 1;

		if self.count < 6{
			Some(self.count)
		}else{
			None
		}
	}
}

#[test]
fn using_other_iterator_trait_methods(){
	let sum: u32 = Counter::new().zip(Counter::new().skip(1))
								.map(|(a, b)| a * b)
								.filter(|x| x % 3 == 0)
								.sum();
	assert_eq!(18, sum);

use std::thread;
use std::time:Duration;
fn main(){
	let handle = thread::spawn(|| {
		//`thread::spawn`接受一个闭包作为参数，返回
		//`JoinHandle`类型的值（不是引用）
		for i in 1..10{
			println!("number {} from spwaned thread!", i);
			thread::sleep(Duration::from_millis(1));
		}
	);

	for i in 1..5{
		println!("number{} from main thread!", i);
		thread::sleep(Duration::from_millis(1));
	}

	handle.join().wrap();
		//`JoinHandle.join()`将阻塞直到其对应的线程结束
		//如果调用`join`，spawn线程可能无法执行完毕
		//因为主线程执行完，整个进行结束
		//注意`join`调用的位置决定阻塞的位置

	let v = vec![1, 2 , 3];
	let handle = thread::spawn(move || {
		//这里`move`关键字将捕获的外部环境中变量`v`所有权
		//移入spawn线程，否则无法正常编译
		prinln!("here's a vector: {:?}", v);
	});
	handle.join().unwrap();
}

use std::thread;
use std::sync:mpsc;
use std::time:Duration;

fn main(){
	let (tx, rx) = mpsc::channel();
		//`tx`表示发送端，`rx`表示接收端

	let tx1 = mpsc::Sender::clone(&tx);
		//clone发送端创建多个生产者

	thread::spawn(move || {
		let vals = vec![
			String::from("hi"),
			String::from("from"),
			String::from("the"),
			String::from("thread"),
		];

		for val in vals {
			tx1.send(val).unwrap();
				//`send`会获取参数所有权归接收者所有，避免
				//值被其他线程丢弃、修改导致意外结果

				//`send`返回`Result<T, E>`，如果接收端被丢弃
				//将没有发送值的目标，将返回`Err<E>`
			thread::sleep(Duration::from_secs(1));
		}
	});

	thread::spawn(move || {d
		let vals = vec![
			String::from("move"),
			String::from("messages"),
			String::from("for"),
			String::from("you"),
		];
		
		for val in vals{
			tx.send(val).unwrap();
			thread::sleep(Duration::from_secs(1));
		}
	});

	let received = rx.recv().unwrap();
		//`recv`将阻塞直到接收到一个值，返回`Result<T, E>`
		//通道发送端关闭时`recv`将返回`Err<E>`表明不会有新值

	let received = rx.try_recv().unwrap();
		//`try_recv`不阻塞，立刻返回`Result<T, E>`，`Err<E>`
		//表示当前没有消息
		//可以再循环中多次调用`try_recv`，有消息进行处理，
		//否则进行其他工作直到下次调用`try_recv`

	for received in rx{
		//将接收端`rx`当作迭代器使用，返回接收到值
		println!("Got: {}", received);
	}
}

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

fn main(){
	let counter = Arc::new(Mutex::new(0));
		//因为需要在多个线程内引用，所以需要使用多所有权
		//数据结构，而`Rc`不是线程安全的，需要使用线程安全
		//`Arc`
	let mut handles = vec![];

	for _ in 0..10{
		let counter = Arc::clone(&counter);
		let handle = thread::spawn(move || {
			let mut num = counter.lock().unwrap();
			//`lock`返回一个`MutexGuard`类型的智能指针，
			//实现了`Deref`指向其内部数据，`Drop`当
			//`MutexGuard`离开作用域时自动释放锁

			//只有`lock`才能获取值，类型系统保证访问数据之前
			//获取锁；而锁的释放自动发生，保证锁一定会释放

			//这里发生了一次强制解引用多态，将`counter`
			//解引用为`Mutex<T>`类型
			*num += 1;
		});

		handles.push(handle);
	}

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

vec![Message::Write(String::from("ab"), Message::Move{x:5, y:6}]

let mut v:Vec<i32> = Vec::new();
let mut v = Vec::with_capacity(3);
	//为vector预先分配空间，比`new`稍有效率
	//但是这个为啥不用指定类型啊，这样怎么分配空间
let v = vec![1, 2, 3];

v.push(5)
let third:&i32 = &v[2]
	//尝试获取一个引用值，如果越界则报错
let third:Option<&i32> = v.get(2)
	//尝试获取Option<&i32>，越界则返回None

let mut v = vec![100, 32, 57]
for i in &mut v{
	*i += 50;
}

let iter = v.iter();
	//不可变引用迭代器
let iter_mut = v.iter_mut();
	//可变引用迭代器
let iter_owner = v.into_iter();
	//所有权引用迭代器

let len = String::from("Здравствуйте").len()
	//`len`返回的是utf-8编码序列的长度20，不是“字符”数目12

let hello = "Здравствуйте";
let s = &hello[0..4];

let mut s = String::new();
let s = String::from("initial contet");

let data = "initial content";
let s = data.to_string();
let s = "initial content".to_string();

let mut s = String::from("foo");
s.push_str("bar");
let s2 = "bar";
s.push_str(&s2);
println!(s2);
	//此时，`s2`仍然可以打印出来，因为`push_str`的参数是它的
	//一个引用，应该是方法中对`&&str`类型做了处理？
s.push('l');

let s1 = String::from("hello, ");
let s2 = String::from("world";
let s3 = s1 + &s2;
	//此时`s1`所有权被转移给`s3`不能再使用

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = string::from("toc");
//let s = s1 + "-" + &s2 + "-" + &s3;
let s = format!("{}-{}-{}", s1, s2, s3);
	//`format!`宏是更好地连接字符串的方法，且不会获取任何
	//参数的所有权

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 30);
	//对于没有实现`copy`trait的`string`类型，所有权将转移给
	//HashMap
scores.insert(String::from("Blue", 20);
	//之前存储的值被覆盖

scores.entry(String::from("Yellow")).or_insert(90);
scores.entry(String::from("Red")).or_insert(90);
	//`entry`以想要检查的键作为参数，返回`Entry`类型的枚举
	//代表可能存在的值，`or_insert`方法在键对应的值存在时
	//返回值`Entry`（实际上时值的可变引用），否则将参数作为
	//新值插入，并返回修改后的`Entry`

let text = "hello world wonderful word";
let mut map = HashMap::new();
for word in text.split_whitespace(){
	let count = map.entry(word).or_insert(0);
	*count += 1;
}
	//这段将在`map`中存储`text`中个单词出现次数

let teams = vec![String::from("Blue"), String::from("Yello")];
let initial_scores = vec![10, 30];
let scores: HashMap<_,_> = teams.iter.zip(initial_scores.iter()).collect();
	//`collect`可能返回很多不同的数据结构，需要显式指定`scores`
	//的类型`HashMap<_,_>`

let team_name = String::from("Blue");
let team_score = scores.get(&team_name);

for (key, val) in &scores{
	println!("{}:{}", key, val);
}

fn main(){
	let x = 5;
	let y = &x;
	let z = Box::new(5);

	assert_eq!(5, x);
	assert_eq!(5, *y);
	assert_eq!(5, *z);

struct MyBox<T>(T);
	//`Box<T>`从本质上被定义为包含一个元素的元组结构体
	//类似定义自定义类型`MyBox`
impl<T> MyBox<T>{
	fn new(x: T) -> MyBox<T>{
		MyBox(X)
	}
}

use::std::Deref;
impl<T> Deref for MyBox<T>{
	type Target = T;

	fn deref(&self) -> &T{
		&sell.0
	}
		//`deref`返回引用，因为大部分使用解引用时不希望获取
		//`MyBox`内部值的所有权
}
//为`MyBox<T>`实现`Deref`trait

fn main(){
	let x = 5;
	let y = MyBox::new(x);

	println!("y = {}", *y);
		//对于`*y`Rust实际在底层`*(y.deref())`
}

fn hello(name: &str){
	println!("hello, {}", name);
}
fn main(){
	let m = MyBox::new(String::from("Rust"));
	hello(&m);
}

struct CustomSmartPointer{
	data: String,
}

impl Drop for CustomSmartPointer{
	fn drop(&mut self){
		println!("Dropping CustomSmartPointer with data `{}`!", self.data);
	}
}

fn main(){
	let c = CustomSmartPointer{ data: String::from("pointer1")};
	let d = CustomSmartPointer{ data: String::from("pointer2")};
	println!("CustomSmartPointer created!");
}

CustomSmartPointer created!
Dropping CustomSmartPointer with data `pointer1`!
Dropping CustomSmartPointer with data `pointer2`!

fn man(){
	let c = CustomSmartPointer{ data: String::from("some data")};
	println!("CumstomSmartPointer Created");
	drop(c);
		//调用`std::mem::drop`函数，不是`c.drop()`方法
	println!("CustomSmartPointer dropped before the end of main");

let b = Box::new(5);
println!("b = {}", b);
	//可以像数据存储在栈上一样访问数据
	//box离开作用域时，栈上和指向的堆上的数据都被释放

enum List{
	Cons(i32, Box<list>),
	Nil,
		//代表递归终止条件的规范名称，表示列表的终止
		//不同于`null`或`nil`
}

use List::{Cons, Nil};

fn main(){
	let list = Cons(1,
		Box::new(Cons(2,
			Box::new(Cons(3,
				Box::new(Nil))))));
}

enum List{
	Cons(i32, Rc<List>),
	Nil,
}
	//使用`Rc<T>`代替`Box<T>`，可以构造共享List

use List::{Cons, Nil};
use std::rc::Rc;

fn main(){
	let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
	println!("count after creating a = {}", Rc::strong_count(&a));
		//1

	let b = Cons::(3, Rc::clone(&a));
		//`Rc::clone`并不像大多数`clone`方法一样对所有数据
		//进行深拷贝，只会增加引用计数，允许`a`和`b`**共享**
		//`Rc`中数据的所有权
		//这里可以调用`a.clone()`代替`Rc::clone(&a)`，但是
		//习惯上使用`Rc::cloen(&a)`
	println!("count after creating b = {}", Rc::strong_count(&a));
		//2

	{
		let c = Cons::(4, Rc::clone(&a));
		println!("count after creating c = {}", Rc::strong_count(&a));
			//3
	}

	println!("count after c goes out of scope = {}", Rc::strong_count(&a));
		//2
}

pub trait Messenger{
	fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T:'a + Messenger>{
	Messenger:&'a T,
	value: usize,
	max : usize,
}
	//这个结构体有`‘a`和`T`两个泛型参数，且`T`还以生命周期
	//注解作为trait bound

impl<'a, T> LimitTracker<a', T>
	where T: Messenger{
	//这里的`T`就没有加上`‘a`作为trait bound
	pub fn new(messenger: &T, max: usize) -> LimitTracker<T>{
		LimitTracker{
			messenger,
			value: 0,
			max,
		}
	}

	pub fn set_value(&mut self, value:usize){
		self.value = value;
		let percentage_of_max = self.max as f64 / self.max as f64;
		if percentage_of_max >= 0.75{
			self.messenger.send("Warning: over 75% of quota has been used!");
		}
	}

}

#[cfg(test)]
mod tests{
	use supper::*;
	use std::cell:RefCell;

	struct MockMessenger{
		sent_messages: RefCell<Vec<String>>,
	}
	impl MockMessenger{
		fn new() -> MockMessenger{
			MockMessenger{ sent_messages: RefCell<vec![]> }
		}
	}
	impl Messenger for MockMessenger{
		fn send(&self, message: &str){
			self.sent_messages.borrow_mut().push(String::from(message));
		}
	}

	#[test]
	fn it_send_an_over_75_percent_warning_message(){
		let mock_messenger = MockMessenger::new();
		let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
		limit_tracker.set_value(80);

		assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
	}
}

#[derive(Debug)]
enum List{
	Cons(Rc<RefCell<i32>>, Rc<List>),
	Nil
}

use List::{Cons, Nil};
use std::rc::Rc;
use std::cell::RefCell;

fn main(){
	let value = Rc::new(RefCell::new(5));
	let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
	let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a));
	let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a));
	
	*value.borrow_value += 10;
	println!("a after = {:?}", a);
	println!("b after = {:?}", b);
	println!("c after = {:?}", c);
}

use List::{Cons, Nil};
use std::rc::Rc;
use std::cell::RefCell;
enum List{
	Cons(i32, RefCell<Rc<list>>),
	Nil,
}
impl List{
	fn tail(&self) -> Option<&RefCell<R<List>>>{
		match *self{
			Cons(_, ref item) => Some(item),
			Nil => None,
		}
	}
}

fn main(){
	let a = Rc::new(Cons(5, RefCell::new(Rc::New(Nil))));
	println!("a initial rc count ={}", Rc::strong_count(&a));
		//1
	println!("a next item = {:?}", a.tail());
	
	let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
	println!("a rc count after b creating = {}", Rc::strong_count(&a));
		//2
	println!("b initial rc count = {}", Rc::strong_count(&b));
		//1
	println!("b next item = {:?}"<, b.tail());

	if let Some(link) = a.tail(){
		*link.borrow_mut() = Rc::clone(&b);
			//此时`a`、`b`循环引用，离开作用域时，两个值的
			//引用计数因为`a`、`b`被丢弃而减1，但是它们互相
			//引用，引用计数保持在1，在堆上不会被丢弃
	}
	println!("b rc count after changing a = {}", Rc::strong_count(&b));
		//2
	println!("a rc count after changing a = {}", Rc::strong_count(&a));
		//2
}