]>
Commit | Line | Data |
---|---|---|
1 | //! # The Rust core allocation and collections library | |
2 | //! | |
3 | //! This library provides smart pointers and collections for managing | |
4 | //! heap-allocated values. | |
5 | //! | |
6 | //! This library, like libcore, normally doesn’t need to be used directly | |
7 | //! since its contents are re-exported in the [`std` crate](../std/index.html). | |
8 | //! Crates that use the `#![no_std]` attribute however will typically | |
9 | //! not depend on `std`, so they’d use this crate instead. | |
10 | //! | |
11 | //! ## Boxed values | |
12 | //! | |
13 | //! The [`Box`] type is a smart pointer type. There can only be one owner of a | |
14 | //! [`Box`], and the owner can decide to mutate the contents, which live on the | |
15 | //! heap. | |
16 | //! | |
17 | //! This type can be sent among threads efficiently as the size of a `Box` value | |
18 | //! is the same as that of a pointer. Tree-like data structures are often built | |
19 | //! with boxes because each node often has only one owner, the parent. | |
20 | //! | |
21 | //! ## Reference counted pointers | |
22 | //! | |
23 | //! The [`Rc`] type is a non-threadsafe reference-counted pointer type intended | |
24 | //! for sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and | |
25 | //! only allows access to `&T`, a shared reference. | |
26 | //! | |
27 | //! This type is useful when inherited mutability (such as using [`Box`]) is too | |
28 | //! constraining for an application, and is often paired with the [`Cell`] or | |
29 | //! [`RefCell`] types in order to allow mutation. | |
30 | //! | |
31 | //! ## Atomically reference counted pointers | |
32 | //! | |
33 | //! The [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It | |
34 | //! provides all the same functionality of [`Rc`], except it requires that the | |
35 | //! contained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself | |
36 | //! sendable while [`Rc<T>`][`Rc`] is not. | |
37 | //! | |
38 | //! This type allows for shared access to the contained data, and is often | |
39 | //! paired with synchronization primitives such as mutexes to allow mutation of | |
40 | //! shared resources. | |
41 | //! | |
42 | //! ## Collections | |
43 | //! | |
44 | //! Implementations of the most common general purpose data structures are | |
45 | //! defined in this library. They are re-exported through the | |
46 | //! [standard collections library](../std/collections/index.html). | |
47 | //! | |
48 | //! ## Heap interfaces | |
49 | //! | |
50 | //! The [`alloc`](alloc/index.html) module defines the low-level interface to the | |
51 | //! default global allocator. It is not compatible with the libc allocator API. | |
52 | //! | |
53 | //! [`Arc`]: sync/index.html | |
54 | //! [`Box`]: boxed/index.html | |
55 | //! [`Cell`]: ../core/cell/index.html | |
56 | //! [`Rc`]: rc/index.html | |
57 | //! [`RefCell`]: ../core/cell/index.html | |
58 | ||
59 | #![allow(unused_attributes)] | |
60 | #![stable(feature = "alloc", since = "1.36.0")] | |
61 | #![doc( | |
62 | html_root_url = "https://doc.rust-lang.org/nightly/", | |
63 | html_playground_url = "https://play.rust-lang.org/", | |
64 | issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/", | |
65 | test(no_crate_inject, attr(allow(unused_variables), deny(warnings))) | |
66 | )] | |
67 | #![no_std] | |
68 | #![needs_allocator] | |
69 | #![warn(deprecated_in_future)] | |
70 | #![warn(missing_docs)] | |
71 | #![warn(missing_debug_implementations)] | |
72 | #![deny(intra_doc_link_resolution_failure)] // rustdoc is run without -D warnings | |
73 | #![allow(explicit_outlives_requirements)] | |
74 | #![allow(incomplete_features)] | |
75 | #![deny(unsafe_op_in_unsafe_fn)] | |
76 | #![cfg_attr(not(test), feature(generator_trait))] | |
77 | #![cfg_attr(test, feature(test))] | |
78 | #![feature(allocator_api)] | |
79 | #![feature(allow_internal_unstable)] | |
80 | #![feature(arbitrary_self_types)] | |
81 | #![feature(box_patterns)] | |
82 | #![feature(box_syntax)] | |
83 | #![feature(cfg_sanitize)] | |
84 | #![feature(cfg_target_has_atomic)] | |
85 | #![feature(coerce_unsized)] | |
86 | #![feature(const_btree_new)] | |
87 | #![feature(const_generic_impls_guard)] | |
88 | #![feature(const_generics)] | |
89 | #![feature(const_in_array_repeat_expressions)] | |
90 | #![cfg_attr(bootstrap, feature(const_if_match))] | |
91 | #![feature(cow_is_borrowed)] | |
92 | #![feature(deque_range)] | |
93 | #![feature(dispatch_from_dyn)] | |
94 | #![feature(core_intrinsics)] | |
95 | #![feature(container_error_extra)] | |
96 | #![feature(dropck_eyepatch)] | |
97 | #![feature(exact_size_is_empty)] | |
98 | #![feature(extend_one)] | |
99 | #![feature(fmt_internals)] | |
100 | #![feature(fn_traits)] | |
101 | #![feature(fundamental)] | |
102 | #![feature(internal_uninit_const)] | |
103 | #![feature(lang_items)] | |
104 | #![feature(layout_for_ptr)] | |
105 | #![feature(libc)] | |
106 | #![feature(negative_impls)] | |
107 | #![feature(new_uninit)] | |
108 | #![feature(nll)] | |
109 | #![feature(optin_builtin_traits)] | |
110 | #![feature(or_patterns)] | |
111 | #![feature(pattern)] | |
112 | #![feature(ptr_internals)] | |
113 | #![feature(ptr_offset_from)] | |
114 | #![feature(raw_ref_op)] | |
115 | #![feature(rustc_attrs)] | |
116 | #![feature(receiver_trait)] | |
117 | #![feature(min_specialization)] | |
118 | #![feature(staged_api)] | |
119 | #![feature(std_internals)] | |
120 | #![feature(str_internals)] | |
121 | #![feature(trusted_len)] | |
122 | #![feature(try_reserve)] | |
123 | #![feature(unboxed_closures)] | |
124 | #![feature(unicode_internals)] | |
125 | #![feature(unsafe_block_in_unsafe_fn)] | |
126 | #![feature(unsize)] | |
127 | #![feature(unsized_locals)] | |
128 | #![feature(allocator_internals)] | |
129 | #![feature(slice_partition_dedup)] | |
130 | #![feature(maybe_uninit_extra, maybe_uninit_slice)] | |
131 | #![feature(alloc_layout_extra)] | |
132 | #![feature(try_trait)] | |
133 | #![feature(associated_type_bounds)] | |
134 | ||
135 | // Allow testing this library | |
136 | ||
137 | #[cfg(test)] | |
138 | #[macro_use] | |
139 | extern crate std; | |
140 | #[cfg(test)] | |
141 | extern crate test; | |
142 | ||
143 | // Module with internal macros used by other modules (needs to be included before other modules). | |
144 | #[macro_use] | |
145 | mod macros; | |
146 | ||
147 | // Heaps provided for low-level allocation strategies | |
148 | ||
149 | pub mod alloc; | |
150 | ||
151 | // Primitive types using the heaps above | |
152 | ||
153 | // Need to conditionally define the mod from `boxed.rs` to avoid | |
154 | // duplicating the lang-items when building in test cfg; but also need | |
155 | // to allow code to have `use boxed::Box;` declarations. | |
156 | #[cfg(not(test))] | |
157 | pub mod boxed; | |
158 | #[cfg(test)] | |
159 | mod boxed { | |
160 | pub use std::boxed::Box; | |
161 | } | |
162 | pub mod borrow; | |
163 | pub mod collections; | |
164 | pub mod fmt; | |
165 | pub mod prelude; | |
166 | pub mod raw_vec; | |
167 | pub mod rc; | |
168 | pub mod slice; | |
169 | pub mod str; | |
170 | pub mod string; | |
171 | #[cfg(target_has_atomic = "ptr")] | |
172 | pub mod sync; | |
173 | #[cfg(target_has_atomic = "ptr")] | |
174 | pub mod task; | |
175 | #[cfg(test)] | |
176 | mod tests; | |
177 | pub mod vec; | |
178 | ||
179 | #[cfg(not(test))] | |
180 | mod std { | |
181 | pub use core::ops; // RangeFull | |
182 | } | |
183 | ||
184 | #[doc(hidden)] | |
185 | #[unstable(feature = "liballoc_internals", issue = "none", reason = "implementation detail")] | |
186 | pub mod __export { | |
187 | pub use core::format_args; | |
188 | } |