compat_no_std/
generated.rs1pub mod alloc {
4 pub use __core::alloc::*;
5 #[cfg(feature = "alloc")] pub use __alloc::alloc::*;
6}
7pub mod any {
8 pub use __core::any::*;
9}
10pub mod arch {
11 pub use __core::arch::*;
12}
13pub mod array {
14 pub use __core::array::*;
15}
16pub mod ascii {
17 pub use __core::ascii::*;
18}
19pub mod borrow {
20 pub use __core::borrow::*;
21 #[cfg(feature = "alloc")] pub use __alloc::borrow::*;
22}
23pub mod boxed {
24 #[cfg(feature = "alloc")] pub use __alloc::boxed::*;
25}
26pub mod cell {
27 pub use __core::cell::*;
28}
29pub mod char {
30 pub use __core::char::*;
31}
32pub mod clone {
33 pub use __core::clone::*;
34}
35pub mod cmp {
36 pub use __core::cmp::*;
37}
38pub mod collections {
39 #[cfg(feature = "alloc")] pub use __alloc::collections::*;
40 #[cfg(all(feature = "alloc", feature = "compat_hash"))] pub use hashbrown::HashMap;
41 #[cfg(all(feature = "alloc", feature = "compat_hash"))] pub use hashbrown::HashSet;
42}
43
44#[cfg(feature = "compat_guard_unwrap")]
45pub mod compat_guard_unwrap {
46 pub trait UnwrapExt: Sized {
47 fn unwrap(self) -> Self { self }
48 }
49 #[cfg(all(feature = "alloc", feature = "compat_sync"))] impl<'a, T: ?Sized> UnwrapExt for super::sync::MutexGuard<'a, T> {}
50 #[cfg(all(feature = "alloc", feature = "compat_sync"))] impl<'a, T: ?Sized> UnwrapExt for super::sync::RwLockReadGuard<'a, T> {}
51 #[cfg(all(feature = "alloc", feature = "compat_sync"))] impl<'a, T: ?Sized> UnwrapExt for super::sync::RwLockWriteGuard<'a, T> {}
52}
53pub mod convert {
54 pub use __core::convert::*;
55}
56pub mod default {
57 pub use __core::default::*;
58}
59pub mod f32 {
60 pub use __core::f32::*;
61}
62pub mod f64 {
63 pub use __core::f64::*;
64}
65pub mod ffi {
66 pub use __core::ffi::*;
67 #[cfg(all(feature = "alloc", feature = "compat_cstr"))] pub use cstr_core::CStr;
68}
69pub mod fmt {
70 pub use __core::fmt::*;
71 #[cfg(feature = "alloc")] pub use __alloc::fmt::*;
72}
73pub mod future {
74 pub use __core::future::*;
75}
76pub mod hash {
77 pub use __core::hash::*;
78}
79pub mod hint {
80 pub use __core::hint::*;
81}
82pub mod i128 {
83 pub use __core::i128::*;
84}
85pub mod i16 {
86 pub use __core::i16::*;
87}
88pub mod i32 {
89 pub use __core::i32::*;
90}
91pub mod i64 {
92 pub use __core::i64::*;
93}
94pub mod i8 {
95 pub use __core::i8::*;
96}
97pub mod intrinsics {
98 #[cfg(feature = "unstable")] pub use __core::intrinsics::*;
99}
100pub mod isize {
101 pub use __core::isize::*;
102}
103pub mod iter {
104 pub use __core::iter::*;
105}
106pub mod lazy {
107 #[cfg(feature = "unstable")] pub use __core::lazy::*;
108}
109pub mod marker {
110 pub use __core::marker::*;
111}
112pub mod mem {
113 pub use __core::mem::*;
114}
115pub mod num {
116 pub use __core::num::*;
117}
118pub mod ops {
119 pub use __core::ops::*;
120}
121pub mod option {
122 pub use __core::option::*;
123}
124pub mod os {
125 pub mod raw {
126 pub use __core::ffi::c_void;
127 #[cfg(all(feature = "compat_osraw"))] pub use libc::{c_char, c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong, c_ulonglong, c_ushort};
128 }
129}
130pub mod panic {
131 #[cfg(feature = "unstable")] pub use __core::panic::*;
132}
133pub mod panicking {
134 #[cfg(feature = "unstable")] pub use __core::panicking::*;
135}
136pub mod path {
137 #[cfg(feature = "compat_path")] pub use unix_path::*;
138}
139pub mod pin {
140 pub use __core::pin::*;
141}
142pub mod prelude {
143 pub mod v1 {
144 pub use __core::prelude::v1::*;
146 #[cfg(all(feature = "alloc", feature = "unstable"))]
147 pub use __alloc::prelude::v1::*;
148 #[cfg(all(feature = "alloc", not(feature = "unstable")))]
149 pub use __alloc::{
150 borrow::ToOwned,
151 boxed::Box,
152 string::String,
154 string::ToString,
155 vec::Vec,
156 };
157
158 #[cfg(feature = "alloc")]
160 pub use __alloc::{format, vec};
161 #[cfg(feature = "compat_macros")]
162 pub use crate::{print, println, eprint, eprintln, dbg};
163 #[cfg(feature = "compat_guard_unwrap")] pub use crate::compat_guard_unwrap::UnwrapExt as __CompatGuardUnwrapExt;
164 }
165}
166pub mod primitive {
167 pub use __core::primitive::*;
168}
169pub mod ptr {
170 pub use __core::ptr::*;
171}
172pub mod raw {
173 #[cfg(feature = "unstable")] pub use __core::raw::*;
174}
175pub mod raw_vec {
176 #[cfg(all(feature = "alloc", feature = "unstable"))] pub use __alloc::raw_vec::*;
177}
178pub mod rc {
179 #[cfg(feature = "alloc")] pub use __alloc::rc::*;
180}
181pub mod result {
182 pub use __core::result::*;
183}
184pub mod slice {
185 pub use __core::slice::*;
186 #[cfg(feature = "alloc")] pub use __alloc::slice::*;
187}
188pub mod str {
189 pub use __core::str::*;
190 #[cfg(feature = "alloc")] pub use __alloc::str::*;
191}
192pub mod stream {
193 #[cfg(feature = "unstable")] pub use __core::stream::*;
194}
195pub mod string {
196 #[cfg(feature = "alloc")] pub use __alloc::string::*;
197}
198pub mod sync {
199 pub use __core::sync::*;
200 #[cfg(all(feature = "alloc", not(target_os = "none")))] pub use __alloc::sync::*;
201 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::Mutex;
202 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::MutexGuard;
203 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::Once;
204 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::RwLock;
205 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::RwLockReadGuard;
206 #[cfg(all(feature = "alloc", feature = "compat_sync"))] pub use spin::RwLockWriteGuard;
207}
208pub mod task {
209 pub use __core::task::*;
210 #[cfg(all(feature = "alloc", not(target_os = "none")))] pub use __alloc::task::*;
211}
212pub mod time {
213 pub use __core::time::*;
214}
215pub mod u128 {
216 pub use __core::u128::*;
217}
218pub mod u16 {
219 pub use __core::u16::*;
220}
221pub mod u32 {
222 pub use __core::u32::*;
223}
224pub mod u64 {
225 pub use __core::u64::*;
226}
227pub mod u8 {
228 pub use __core::u8::*;
229}
230pub mod unicode {
231 #[cfg(feature = "unstable")] pub use __core::unicode::*;
232}
233pub mod usize {
234 pub use __core::usize::*;
235}
236pub mod vec {
237 #[cfg(feature = "alloc")] pub use __alloc::vec::*;
238}