unsafe-send-sync 0.2.0

Unsafe wrappers for making structs Send and/or Sync.
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

use std::ops::{Deref, DerefMut};


/// A wrapper type that is always `Send`.
pub struct UnsafeSend<T>(pub T);
unsafe impl<T> Send for UnsafeSend<T> {}

impl<T> UnsafeSend<T> {
	pub fn new(internal: T) -> Self { Self(internal) }

	pub fn unwrap(self) -> T { self.0 }
}

impl<T> AsMut<T> for UnsafeSend<T> {
	fn as_mut(&mut self) -> &mut T { &mut self.0 }
}

impl<T> AsRef<T> for UnsafeSend<T> {
	fn as_ref(&self) -> &T { &self.0 }
}

impl<T> Clone for UnsafeSend<T>
where
	T: Clone,
{
	fn clone(&self) -> Self { Self(self.0.clone()) }
}

impl<T> Default for UnsafeSend<T>
where
	T: Default,
{
	fn default() -> Self { Self(T::default()) }
}

impl<T> Deref for UnsafeSend<T> {
	type Target = T;

	fn deref(&self) -> &Self::Target { &self.0 }
}

impl<T> DerefMut for UnsafeSend<T> {
	fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}

impl<T> From<T> for UnsafeSend<T> {
	fn from(other: T) -> Self { Self(other) }
}


/// A wrapper type that is always `Sync`.
pub struct UnsafeSync<T>(pub T);
unsafe impl<T> Sync for UnsafeSync<T> {}

impl<T> UnsafeSync<T> {
	pub fn new(internal: T) -> Self { Self(internal) }

	pub fn unwrap(self) -> T { self.0 }
}

impl<T> AsMut<T> for UnsafeSync<T> {
	fn as_mut(&mut self) -> &mut T { &mut self.0 }
}

impl<T> AsRef<T> for UnsafeSync<T> {
	fn as_ref(&self) -> &T { &self.0 }
}

impl<T> Clone for UnsafeSync<T>
where
	T: Clone,
{
	fn clone(&self) -> Self { Self::new(self.0.clone()) }
}


impl<T> Default for UnsafeSync<T>
where
	T: Default,
{
	fn default() -> Self { Self(T::default()) }
}

impl<T> Deref for UnsafeSync<T> {
	type Target = T;

	fn deref(&self) -> &Self::Target { &self.0 }
}

impl<T> DerefMut for UnsafeSync<T> {
	fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}

impl<T> From<T> for UnsafeSync<T> {
	fn from(other: T) -> Self { Self(other) }
}


/// A wrapper type that is always `Send` and `Sync`.
pub struct UnsafeSendSync<T>(pub T);
unsafe impl<T> Send for UnsafeSendSync<T> {}
unsafe impl<T> Sync for UnsafeSendSync<T> {}

impl<T> UnsafeSendSync<T> {
	pub fn new(internal: T) -> Self { Self(internal) }

	pub fn unwrap(self) -> T { self.0 }
}

impl<T> AsMut<T> for UnsafeSendSync<T> {
	fn as_mut(&mut self) -> &mut T { &mut self.0 }
}

impl<T> AsRef<T> for UnsafeSendSync<T> {
	fn as_ref(&self) -> &T { &self.0 }
}

impl<T> Default for UnsafeSendSync<T>
where
	T: Default,
{
	fn default() -> Self { Self(T::default()) }
}

impl<T> Deref for UnsafeSendSync<T> {
	type Target = T;

	fn deref(&self) -> &Self::Target { &self.0 }
}

impl<T> DerefMut for UnsafeSendSync<T> {
	fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}

impl<T> Clone for UnsafeSendSync<T>
where
	T: Clone,
{
	fn clone(&self) -> Self { Self::new(self.0.clone()) }
}

impl<T> From<T> for UnsafeSendSync<T> {
	fn from(other: T) -> Self { Self(other) }
}