Lines Matching refs:not
58 #[cfg(not(no_global_oom_handling))]
71 #[cfg(not(no_borrow))]
82 #[cfg(not(no_global_oom_handling))]
86 #[cfg(not(no_global_oom_handling))]
94 #[cfg(not(no_borrow))]
95 #[cfg(not(no_global_oom_handling))]
98 #[cfg(not(no_global_oom_handling))]
105 #[cfg(not(no_global_oom_handling))]
110 #[cfg(not(no_global_oom_handling))]
115 #[cfg(not(no_global_oom_handling))]
118 #[cfg(not(no_global_oom_handling))]
125 #[cfg(not(no_global_oom_handling))]
128 #[cfg(not(no_global_oom_handling))]
131 #[cfg(not(no_global_oom_handling))]
134 #[cfg(not(no_global_oom_handling))]
137 #[cfg(not(no_global_oom_handling))]
140 #[cfg(not(no_global_oom_handling))]
143 #[cfg(not(no_global_oom_handling))]
265 /// elements that will be added onto the vector. This is not to be confused with
273 /// vector will not change its capacity or cause reallocation to occur. However,
292 /// However, the pointer might not actually point to allocated memory. In particular,
295 /// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
296 /// types inside a `Vec`, it will not allocate space for them. *Note that in this case
297 /// the `Vec` might not report a [`capacity`] of 0*. `Vec` will allocate if and only
327 /// - **uninit** represents memory that is not initialized, see [`MaybeUninit`].
328 /// - Note: the ABI is not stable and `Vec` makes no guarantees about its memory
353 /// when not necessary.
355 /// `Vec` does not guarantee any particular growth strategy when reallocating
366 /// `Vec` will not specifically overwrite any data that is removed from it,
369 /// whatever is most efficient or otherwise easy to implement. Do not rely on
372 /// first, that might not actually happen because the optimizer does not consider
374 /// not break, however: using `unsafe` code to write to the excess capacity,
377 /// Currently, `Vec` does not guarantee the order in which elements are dropped.
397 #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")]
411 /// The vector will not allocate until elements are pushed onto it.
431 /// `capacity`. If `capacity` is 0, the vector will not allocate.
477 #[cfg(not(no_global_oom_handling))]
489 /// `capacity`. If `capacity` is 0, the vector will not allocate.
550 /// (`T` having a less strict alignment is not sufficient, the alignment really
567 /// internal data structures. For example it is normally **not** safe
571 /// It's also not safe to build one from a `Vec<u16>` and its length, because
651 /// The vector will not allocate until elements are pushed onto it.
674 /// `capacity`. If `capacity` is 0, the vector will not allocate.
724 #[cfg(not(no_global_oom_handling))]
736 /// `capacity`. If `capacity` is 0, the vector will not allocate.
801 /// (`T` having a less strict alignment is not sufficient, the alignment really
818 /// internal data structures. For example it is **not** safe
820 /// It's also not safe to build one from a `Vec<u16>` and its length, because
1024 #[cfg(not(no_global_oom_handling))]
1031 /// be inserted in the given `Vec<T>`. Unlike [`reserve`], this will not
1038 /// requests. Therefore, capacity can not be relied upon to be precisely
1054 #[cfg(not(no_global_oom_handling))]
1099 /// this will not deliberately over-allocate to speculatively avoid frequent
1105 /// requests. Therefore, capacity can not be relied upon to be precisely
1154 #[cfg(not(no_global_oom_handling))]
1183 #[cfg(not(no_global_oom_handling))]
1216 #[cfg(not(no_global_oom_handling))]
1280 // Note: It's intentional that this is `>` and not `>=`.
1463 /// the inner vectors were not freed prior to the `set_len` call:
1478 /// the contents and thus not leak memory.
1491 /// This does not preserve ordering, but is *O*(1).
1552 #[cfg(not(no_global_oom_handling))]
1701 // Avoid double drop if the drop guard is not executed,
1768 // SAFETY: `deleted_cnt` > 0, so the hole slot must not overlap with current element.
1920 * when `same_bucket` is guaranteed to not panic, this bloats a little
1940 #[cfg(not(no_global_oom_handling))]
1982 /// Unlike [`push`] this method will not reallocate when there's insufficient capacity.
2067 #[cfg(not(no_global_oom_handling))]
2078 #[cfg(not(no_global_oom_handling))]
2240 #[cfg(not(no_global_oom_handling))]
2305 #[cfg(not(no_global_oom_handling))]
2324 /// As of Rust 1.57, this method does not reallocate or shrink the `Vec`,
2325 /// so the leaked allocation may include unused capacity that is not part
2384 // This method is not implemented in terms of `split_at_spare_mut`,
2505 #[cfg(not(no_global_oom_handling))]
2575 #[cfg(not(no_global_oom_handling))]
2626 #[cfg(not(no_global_oom_handling))]
2689 #[cfg(not(no_global_oom_handling))]
2697 // might not realize the store through `ptr` through self.set_len()
2726 // might not realize the store through `ptr` through self.set_len()
2777 #[cfg(not(no_global_oom_handling))]
2784 #[cfg(not(no_global_oom_handling))]
2829 // so they are valid and do not overlap.
2867 #[cfg(not(no_global_oom_handling))]
2870 #[cfg(not(test))]
2877 // required for this method definition, is not available. Instead use the
2936 #[cfg(not(no_global_oom_handling))]
3010 #[cfg(not(no_global_oom_handling))]
3032 #[cfg(not(no_global_oom_handling))]
3087 #[cfg(not(no_global_oom_handling))]
3094 "TrustedLen iterator's size hint is not exact: {:?}",
3127 "TrustedLen iterator's size hint is not exact: {:?}",
3150 /// `replace_with` does not need to be the same length as `range`.
3152 /// `range` is removed even if the iterator is not consumed until the end.
3181 #[cfg(not(no_global_oom_handling))]
3195 /// If the closure returns false, the element will remain in the vector and will not be yielded
3198 /// If the returned `ExtractIf` is not exhausted, e.g. because it is dropped without iterating
3200 /// Use [`retain`] with a negated predicate if you do not need the returned iterator.
3264 #[cfg(not(no_global_oom_handling))]
3325 /// The vector will not allocate until elements are pushed onto it.
3366 #[cfg(not(no_global_oom_handling))]
3376 #[cfg(not(test))]
3386 #[cfg(not(no_global_oom_handling))]
3396 #[cfg(not(test))]
3406 #[cfg(not(no_global_oom_handling))]
3416 #[cfg(not(test))]
3427 #[cfg(not(no_borrow))]
3453 #[cfg(not(test))]
3471 #[cfg(not(no_global_oom_handling))]
3472 #[cfg(not(test))]
3498 #[cfg(not(no_global_oom_handling))]
3554 // The items will not double-drop as the `set_len`
3555 // tells the `Vec` not to also drop them.