1//! Higher-level traits to describe writeable streams
2
3/// Required functionality for underlying [`std::io::Write`] for adaptation
4#[cfg(not(all(windows, feature = "wincon")))]
5pub trait RawStream: std::io::Write + IsTerminal + private::Sealed {}
6
7/// Required functionality for underlying [`std::io::Write`] for adaptation
8#[cfg(all(windows, feature = "wincon"))]
9pub trait RawStream:
10 std::io::Write + IsTerminal + anstyle_wincon::WinconStream + private::Sealed
11{
12}
13
14impl<T: RawStream + ?Sized> RawStream for &mut T {}
15impl<T: RawStream + ?Sized> RawStream for Box<T> {}
16
17impl RawStream for std::io::Stdout {}
18
19impl RawStream for std::io::StdoutLock<'_> {}
20
21impl RawStream for std::io::Stderr {}
22
23impl RawStream for std::io::StderrLock<'_> {}
24
25impl RawStream for dyn std::io::Write {}
26impl RawStream for dyn std::io::Write + Send {}
27impl RawStream for dyn std::io::Write + Send + Sync {}
28
29impl RawStream for Vec<u8> {}
30
31impl RawStream for std::fs::File {}
32
33#[allow(deprecated)]
34impl RawStream for crate::Buffer {}
35
36/// Trait to determine if a descriptor/handle refers to a terminal/tty.
37pub trait IsTerminal: private::Sealed {
38 /// Returns `true` if the descriptor/handle refers to a terminal/tty.
39 fn is_terminal(&self) -> bool;
40}
41
42impl<T: IsTerminal + ?Sized> IsTerminal for &T {
43 #[inline]
44 fn is_terminal(&self) -> bool {
45 (**self).is_terminal()
46 }
47}
48
49impl<T: IsTerminal + ?Sized> IsTerminal for &mut T {
50 #[inline]
51 fn is_terminal(&self) -> bool {
52 (**self).is_terminal()
53 }
54}
55
56impl<T: IsTerminal + ?Sized> IsTerminal for Box<T> {
57 #[inline]
58 fn is_terminal(&self) -> bool {
59 (**self).is_terminal()
60 }
61}
62
63impl IsTerminal for std::io::Stdout {
64 #[inline]
65 fn is_terminal(&self) -> bool {
66 is_terminal_polyfill::IsTerminal::is_terminal(self)
67 }
68}
69
70impl IsTerminal for std::io::StdoutLock<'_> {
71 #[inline]
72 fn is_terminal(&self) -> bool {
73 is_terminal_polyfill::IsTerminal::is_terminal(self)
74 }
75}
76
77impl IsTerminal for std::io::Stderr {
78 #[inline]
79 fn is_terminal(&self) -> bool {
80 is_terminal_polyfill::IsTerminal::is_terminal(self)
81 }
82}
83
84impl IsTerminal for std::io::StderrLock<'_> {
85 #[inline]
86 fn is_terminal(&self) -> bool {
87 is_terminal_polyfill::IsTerminal::is_terminal(self)
88 }
89}
90
91impl IsTerminal for dyn std::io::Write {
92 #[inline]
93 fn is_terminal(&self) -> bool {
94 false
95 }
96}
97
98impl IsTerminal for dyn std::io::Write + Send {
99 #[inline]
100 fn is_terminal(&self) -> bool {
101 false
102 }
103}
104
105impl IsTerminal for dyn std::io::Write + Send + Sync {
106 #[inline]
107 fn is_terminal(&self) -> bool {
108 false
109 }
110}
111
112impl IsTerminal for Vec<u8> {
113 #[inline]
114 fn is_terminal(&self) -> bool {
115 false
116 }
117}
118
119impl IsTerminal for std::fs::File {
120 #[inline]
121 fn is_terminal(&self) -> bool {
122 is_terminal_polyfill::IsTerminal::is_terminal(self)
123 }
124}
125
126#[allow(deprecated)]
127impl IsTerminal for crate::Buffer {
128 #[inline]
129 fn is_terminal(&self) -> bool {
130 false
131 }
132}
133
134/// Lock a stream
135pub trait AsLockedWrite: private::Sealed {
136 /// Locked writer type
137 type Write<'w>: RawStream + 'w
138 where
139 Self: 'w;
140
141 /// Lock a stream
142 fn as_locked_write(&mut self) -> Self::Write<'_>;
143}
144
145impl<T: AsLockedWrite + ?Sized> AsLockedWrite for &mut T {
146 type Write<'w>
147 = T::Write<'w>
148 where
149 Self: 'w;
150
151 #[inline]
152 fn as_locked_write(&mut self) -> Self::Write<'_> {
153 (**self).as_locked_write()
154 }
155}
156
157impl<T: AsLockedWrite + ?Sized> AsLockedWrite for Box<T> {
158 type Write<'w>
159 = T::Write<'w>
160 where
161 Self: 'w;
162
163 #[inline]
164 fn as_locked_write(&mut self) -> Self::Write<'_> {
165 (**self).as_locked_write()
166 }
167}
168
169impl AsLockedWrite for std::io::Stdout {
170 type Write<'w> = std::io::StdoutLock<'w>;
171
172 #[inline]
173 fn as_locked_write(&mut self) -> Self::Write<'_> {
174 self.lock()
175 }
176}
177
178impl AsLockedWrite for std::io::StdoutLock<'static> {
179 type Write<'w> = &'w mut Self;
180
181 #[inline]
182 fn as_locked_write(&mut self) -> Self::Write<'_> {
183 self
184 }
185}
186
187impl AsLockedWrite for std::io::Stderr {
188 type Write<'w> = std::io::StderrLock<'w>;
189
190 #[inline]
191 fn as_locked_write(&mut self) -> Self::Write<'_> {
192 self.lock()
193 }
194}
195
196impl AsLockedWrite for std::io::StderrLock<'static> {
197 type Write<'w> = &'w mut Self;
198
199 #[inline]
200 fn as_locked_write(&mut self) -> Self::Write<'_> {
201 self
202 }
203}
204
205impl AsLockedWrite for dyn std::io::Write {
206 type Write<'w> = &'w mut Self;
207
208 #[inline]
209 fn as_locked_write(&mut self) -> Self::Write<'_> {
210 self
211 }
212}
213
214impl AsLockedWrite for dyn std::io::Write + Send {
215 type Write<'w> = &'w mut Self;
216
217 #[inline]
218 fn as_locked_write(&mut self) -> Self::Write<'_> {
219 self
220 }
221}
222
223impl AsLockedWrite for dyn std::io::Write + Send + Sync {
224 type Write<'w> = &'w mut Self;
225
226 #[inline]
227 fn as_locked_write(&mut self) -> Self::Write<'_> {
228 self
229 }
230}
231
232impl AsLockedWrite for Vec<u8> {
233 type Write<'w> = &'w mut Self;
234
235 #[inline]
236 fn as_locked_write(&mut self) -> Self::Write<'_> {
237 self
238 }
239}
240
241impl AsLockedWrite for std::fs::File {
242 type Write<'w> = &'w mut Self;
243
244 #[inline]
245 fn as_locked_write(&mut self) -> Self::Write<'_> {
246 self
247 }
248}
249
250#[allow(deprecated)]
251impl AsLockedWrite for crate::Buffer {
252 type Write<'w> = &'w mut Self;
253
254 #[inline]
255 fn as_locked_write(&mut self) -> Self::Write<'_> {
256 self
257 }
258}
259
260mod private {
261 pub trait Sealed {}
262
263 impl<T: Sealed + ?Sized> Sealed for &T {}
264 impl<T: Sealed + ?Sized> Sealed for &mut T {}
265 impl<T: Sealed + ?Sized> Sealed for Box<T> {}
266
267 impl Sealed for std::io::Stdout {}
268
269 impl Sealed for std::io::StdoutLock<'_> {}
270
271 impl Sealed for std::io::Stderr {}
272
273 impl Sealed for std::io::StderrLock<'_> {}
274
275 impl Sealed for dyn std::io::Write {}
276 impl Sealed for dyn std::io::Write + Send {}
277 impl Sealed for dyn std::io::Write + Send + Sync {}
278
279 impl Sealed for Vec<u8> {}
280
281 impl Sealed for std::fs::File {}
282
283 #[allow(deprecated)]
284 impl Sealed for crate::Buffer {}
285}
286
287#[cfg(test)]
288mod tests {
289 use super::*;
290
291 fn assert_raw_stream<T: RawStream>()
292 where
293 crate::AutoStream<T>: std::io::Write,
294 {
295 }
296
297 #[test]
298 fn test() {
299 assert_raw_stream::<Box<dyn std::io::Write>>();
300 assert_raw_stream::<Box<dyn std::io::Write + 'static>>();
301 assert_raw_stream::<Box<dyn std::io::Write + Send>>();
302 assert_raw_stream::<Box<dyn std::io::Write + Send + Sync>>();
303
304 assert_raw_stream::<&mut (dyn std::io::Write)>();
305 assert_raw_stream::<&mut (dyn std::io::Write + 'static)>();
306 assert_raw_stream::<&mut (dyn std::io::Write + Send)>();
307 assert_raw_stream::<&mut (dyn std::io::Write + Send + Sync)>();
308
309 assert_raw_stream::<Vec<u8>>();
310 assert_raw_stream::<&mut Vec<u8>>();
311
312 assert_raw_stream::<std::fs::File>();
313 assert_raw_stream::<&mut std::fs::File>();
314 }
315}
316

Provided by KDAB

Privacy Policy
Learn Rust with the experts
Find out more