no-std-compat2 0.4.5

//! Generated by generate.py located at the repository root
//! ./generate.py > src/generated.rs
pub mod alloc {
    #[cfg(feature = "alloc")]
    pub use __alloc::alloc::*;
    pub use __core::alloc::*;
}
pub mod any {
    pub use __core::any::*;
}
pub mod arch {
    pub use __core::arch::*;
}
pub mod array {
    pub use __core::array::*;
}
pub mod ascii {
    pub use __core::ascii::*;
}
pub mod asserting {
    #[cfg(feature = "unstable")]
    pub use __core::asserting::*;
}
pub mod async_iter {
    #[cfg(feature = "unstable")]
    pub use __core::async_iter::*;
}
pub mod borrow {
    #[cfg(feature = "alloc")]
    pub use __alloc::borrow::*;
    pub use __core::borrow::*;
}
pub mod boxed {
    #[cfg(feature = "alloc")]
    pub use __alloc::boxed::*;
}
pub mod cell {
    pub use __core::cell::*;
}
pub mod char {
    pub use __core::char::*;
}
pub mod clone {
    pub use __core::clone::*;
}
pub mod cmp {
    pub use __core::cmp::*;
}
pub mod collections {
    #[cfg(feature = "alloc")]
    pub use __alloc::collections::*;
    #[cfg(all(feature = "alloc", feature = "compat_hash"))]
    pub use hashbrown::HashMap;
    #[cfg(all(feature = "alloc", feature = "compat_hash"))]
    pub use hashbrown::HashSet;
}

#[cfg(feature = "compat_guard_unwrap")]
pub mod compat_guard_unwrap {
    pub trait UnwrapExt: Sized {
        fn unwrap(self) -> Self {
            self
        }
    }
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    impl<'a, T: ?Sized> UnwrapExt for super::sync::MutexGuard<'a, T> {}
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    impl<'a, T: ?Sized> UnwrapExt for super::sync::RwLockReadGuard<'a, T> {}
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    impl<'a, T: ?Sized> UnwrapExt for super::sync::RwLockWriteGuard<'a, T> {}
}
pub mod convert {
    pub use __core::convert::*;
}
pub mod default {
    pub use __core::default::*;
}
pub mod error {
    #[cfg(feature = "unstable")]
    pub use __core::error::*;
}
pub mod f32 {
    pub use __core::f32::*;
}
pub mod f64 {
    pub use __core::f64::*;
}
pub mod ffi {
    #[cfg(feature = "alloc")]
    pub use __alloc::ffi::*;
    pub use __core::ffi::*;
    #[cfg(all(feature = "alloc", feature = "compat_cstr"))]
    pub use cstr_core::CStr;
}
pub mod fmt {
    #[cfg(feature = "alloc")]
    pub use __alloc::fmt::*;
    pub use __core::fmt::*;
}
pub mod future {
    pub use __core::future::*;
}
pub mod hash {
    pub use __core::hash::*;
}
pub mod hint {
    pub use __core::hint::*;
}
pub mod i128 {
    pub use __core::i128::*;
}
pub mod i16 {
    pub use __core::i16::*;
}
pub mod i32 {
    pub use __core::i32::*;
}
pub mod i64 {
    pub use __core::i64::*;
}
pub mod i8 {
    pub use __core::i8::*;
}
pub mod intrinsics {
    #[cfg(feature = "unstable")]
    pub use __core::intrinsics::*;
}
pub mod isize {
    pub use __core::isize::*;
}
pub mod iter {
    pub use __core::iter::*;
}
pub mod marker {
    pub use __core::marker::*;
}
pub mod mem {
    pub use __core::mem::*;
}
pub mod net {
    #[cfg(feature = "unstable")]
    pub use __core::net::*;
}
pub mod num {
    pub use __core::num::*;
}
pub mod ops {
    pub use __core::ops::*;
}
pub mod option {
    pub use __core::option::*;
}
pub mod os {
    pub mod raw {
        pub use __core::ffi::c_void;
        #[cfg(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,
        };
    }
}
pub mod panic {
    pub use __core::panic::*;
}
pub mod panicking {
    #[cfg(feature = "unstable")]
    pub use __core::panicking::*;
}
pub mod path {
    #[cfg(feature = "compat_path")]
    pub use unix_path::*;
}
pub mod pin {
    pub use __core::pin::*;
}
pub mod prelude {
    pub mod v1 {
        // Prelude
        #[cfg(all(feature = "alloc", not(feature = "unstable")))]
        pub use __alloc::{};
        pub use __core::prelude::rust_2021::*;

        // Other imports
        #[cfg(feature = "compat_guard_unwrap")]
        pub use crate::compat_guard_unwrap::UnwrapExt as __CompatGuardUnwrapExt;
        #[cfg(feature = "compat_macros")]
        pub use crate::{dbg, eprint, eprintln, print, println};
        #[cfg(feature = "alloc")]
        pub use __alloc::{
            borrow::ToOwned, boxed::Box, format, string::String, string::ToString, vec, vec::Vec,
        };
    }
}
pub mod primitive {
    pub use __core::primitive::*;
}
pub mod ptr {
    pub use __core::ptr::*;
}
pub mod rc {
    #[cfg(feature = "alloc")]
    pub use __alloc::rc::*;
}
pub mod result {
    pub use __core::result::*;
}
pub mod slice {
    #[cfg(feature = "alloc")]
    pub use __alloc::slice::*;
    pub use __core::slice::*;
}
pub mod str {
    #[cfg(feature = "alloc")]
    pub use __alloc::str::*;
    pub use __core::str::*;
}
pub mod string {
    #[cfg(feature = "alloc")]
    pub use __alloc::string::*;
}
pub mod sync {
    #[cfg(all(feature = "alloc", not(target_os = "none")))]
    pub use __alloc::sync::*;
    pub use __core::sync::*;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::Mutex;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::MutexGuard;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::Once;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::RwLock;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::RwLockReadGuard;
    #[cfg(all(feature = "alloc", feature = "compat_sync"))]
    pub use spin::RwLockWriteGuard;
}
pub mod task {
    #[cfg(all(feature = "alloc", not(target_os = "none")))]
    pub use __alloc::task::*;
    pub use __core::task::*;
}
pub mod time {
    pub use __core::time::*;
}
pub mod u128 {
    pub use __core::u128::*;
}
pub mod u16 {
    pub use __core::u16::*;
}
pub mod u32 {
    pub use __core::u32::*;
}
pub mod u64 {
    pub use __core::u64::*;
}
pub mod u8 {
    pub use __core::u8::*;
}
pub mod unicode {
    #[cfg(feature = "unstable")]
    pub use __core::unicode::*;
}
pub mod usize {
    pub use __core::usize::*;
}
pub mod vec {
    #[cfg(feature = "alloc")]
    pub use __alloc::vec::*;
}