chuchi 0.1.2

Http async library based on hyper and tokio
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::{
	any::{Any, TypeId},
	cell::RefCell,
	collections::{HashMap, HashSet},
	mem::ManuallyDrop,
};

pub struct State {
	inner: HashMap<TypeId, Box<dyn Any + Send>>,
}

impl State {
	pub fn new() -> Self {
		Self {
			inner: HashMap::new(),
		}
	}

	pub fn insert<T>(&mut self, data: T)
	where
		T: Any + Send,
	{
		self.inner.insert(TypeId::of::<T>(), Box::new(data));
	}

	pub fn contains<T>(&self) -> bool
	where
		T: Any + Send,
	{
		self.inner.contains_key(&TypeId::of::<T>())
	}

	pub fn get<T>(&self) -> Option<&T>
	where
		T: Any + Send,
	{
		self.inner
			.get(&TypeId::of::<T>())
			.map(|b| b.downcast_ref::<T>().unwrap())
	}

	pub fn remove<T>(&mut self) -> Option<T>
	where
		T: Any + Send,
	{
		self.inner
			.remove(&TypeId::of::<T>())
			.map(|b| *b.downcast::<T>().unwrap())
	}
}

impl Default for State {
	fn default() -> Self {
		Self::new()
	}
}

pub struct StateValidation {
	inner: HashSet<TypeId>,
}

impl StateValidation {
	pub fn new() -> Self {
		Self {
			inner: HashSet::new(),
		}
	}

	pub fn insert<T>(&mut self)
	where
		T: Any + Send,
	{
		self.inner.insert(TypeId::of::<T>());
	}

	pub fn remove<T>(&mut self)
	where
		T: Any + Send,
	{
		self.inner.remove(&TypeId::of::<T>());
	}

	pub fn validate<T>(&self) -> bool
	where
		T: Any + Send,
	{
		self.inner.contains(&TypeId::of::<T>())
	}
}

impl Default for StateValidation {
	fn default() -> Self {
		Self::new()
	}
}

/// A mutable memory location with dynamically checked borrow rules
///
/// This is similar to `RefCell` but instead of returned wrapped
/// reference, it returns the value directly.
///
/// This means that once the value is borrowed to read it will never
/// get available again.
#[derive(Debug)]
pub struct StateRefCell<T> {
	inner: RefCell<Option<T>>,
}

impl<T> StateRefCell<T> {
	pub const fn new(val: T) -> Self {
		Self {
			inner: RefCell::new(Some(val)),
		}
	}

	/// ## Panics
	/// Panics if the value is currently borrowed.
	pub fn replace(&self, val: T) -> Option<T> {
		self.inner.replace(Some(val))
	}

	/// ## Panics
	/// Panics if the value is currently mutably borrowed.
	pub fn get(&self) -> &T {
		self.try_get().expect("already mutably borrowed")
	}

	/// Tries to get the value if it is not currently borrowed.
	pub fn try_get(&self) -> Option<&T> {
		let r = self.inner.try_borrow().ok()?;

		if r.is_none() {
			return None;
		}

		let r = ManuallyDrop::new(r);
		// since the borrow counter does not get decreased because of the
		// ManuallyDrop and the lifetime not getting expanded this is safe
		let v = unsafe { &*(&**r as *const Option<T>) }.as_ref().unwrap();

		Some(v)
	}

	/// ## Panics
	/// Panics if the value is currently borrowed.
	#[allow(clippy::mut_from_ref)]
	pub fn get_mut(&self) -> &mut T {
		let r = self.inner.borrow_mut();
		let mut r = ManuallyDrop::new(r);
		// since the borrow counter does not get decreased because of the
		// ManuallyDrop and the lifetime not getting expanded this is safe
		unsafe { &mut *(&mut **r as *mut Option<T>) }
			.as_mut()
			.expect("already borrowed")
	}

	/// ## Panics
	/// Panics if the value is currently borrowed.
	pub fn take(&mut self) -> T {
		self.inner.replace(None).expect("already borrowed")
	}

	pub fn into_inner(self) -> T {
		self.inner.into_inner().expect("already borrowed")
	}
}