tinyvec/lib.rs
1#![cfg_attr(not(feature = "std"), no_std)]
2#![forbid(unsafe_code)]
3#![cfg_attr(
4 feature = "nightly_slice_partition_dedup",
5 feature(slice_partition_dedup)
6)]
7#![cfg_attr(
8 feature = "debugger_visualizer",
9 feature(debugger_visualizer),
10 debugger_visualizer(natvis_file = "../debug_metadata/tinyvec.natvis")
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13#![warn(clippy::missing_inline_in_public_items)]
14#![warn(clippy::must_use_candidate)]
15#![warn(missing_docs)]
16#![allow(clippy::borrow_deref_ref)]
17#![allow(unused_imports)]
18#![allow(unused_mut)]
19#![allow(clippy::write_with_newline)]
20#![allow(clippy::needless_return)]
21
22//! `tinyvec` provides 100% safe vec-like data structures.
23//!
24//! ## Provided Types
25//! With no features enabled, this crate provides the [`ArrayVec`] type, which
26//! is an array-backed storage. You can push values into the array and pop them
27//! out of the array and so on. If the array is made to overflow it will panic.
28//!
29//! Similarly, there is also a [`SliceVec`] type available, which is a vec-like
30//! that's backed by a slice you provide. You can add and remove elements, but
31//! if you overflow the slice it will panic.
32//!
33//! With the `alloc` feature enabled, the crate also has a [`TinyVec`] type.
34//! This is an enum type which is either an `Inline(ArrayVec)` or a `Heap(Vec)`.
35//! If a `TinyVec` is `Inline` and would overflow it automatically transitions
36//! itself into being `Heap` mode instead of a panic.
37//!
38//! All of this is done with no `unsafe` code within the crate. Technically the
39//! `Vec` type from the standard library uses `unsafe` internally, but *this
40//! crate* introduces no new `unsafe` code into your project.
41//!
42//! The limitation is that the element type of a vec from this crate must
43//! support the [`Default`] trait. This means that this crate isn't suitable for
44//! all situations, but a very surprising number of types do support `Default`.
45//!
46//! ## Other Features
47//! * `grab_spare_slice` lets you get access to the "inactive" portions of an
48//! ArrayVec.
49//! * `serde` provides a `Serialize` and `Deserialize` implementation for
50//! [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has an
51//! implementation.
52//! * `borsh` provides a `BorshSerialize` and `BorshDeserialize` implementation
53//! for [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has
54//! an implementation.
55//! * `bin-proto` provides a `BitEncode` and `BitDecode` implementation for
56//! [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has an
57//! implementation.
58//! * `defmt` provides a `Format` implementation for all types, provided the
59//! inner item also has an implementation.
60//! * `schemars` provides a `JsonSchema` implementation for [`TinyVec`] and
61//! [`ArrayVec`] types, provided the inner item also has an implementation.
62//!
63//! ## API
64//! The general goal of the crate is that, as much as possible, the vecs here
65//! should be a "drop in" replacement for the standard library `Vec` type. We
66//! strive to provide all of the `Vec` methods with the same names and
67//! signatures. The exception is that the element type of some methods will have
68//! a `Default` bound that's not part of the normal `Vec` type.
69//!
70//! The vecs here also have a few additional methods that aren't on the `Vec`
71//! type. In this case, the names tend to be fairly long so that they are
72//! unlikely to clash with any future methods added to `Vec`.
73
74#[allow(unused_imports)]
75use core::{
76 borrow::{Borrow, BorrowMut},
77 cmp::PartialEq,
78 convert::AsMut,
79 default::Default,
80 fmt::{
81 Binary, Debug, Display, Formatter, LowerExp, LowerHex, Octal, Pointer,
82 UpperExp, UpperHex,
83 },
84 hash::{Hash, Hasher},
85 iter::{Extend, FromIterator, FusedIterator, IntoIterator, Iterator},
86 mem::{needs_drop, replace},
87 ops::{Deref, DerefMut, Index, IndexMut, RangeBounds},
88 slice::SliceIndex,
89};
90
91#[cfg(feature = "alloc")]
92#[doc(hidden)] // re-export for macros
93pub extern crate alloc;
94
95mod array;
96pub use array::*;
97
98mod arrayvec;
99pub use arrayvec::*;
100
101mod arrayvec_drain;
102pub use arrayvec_drain::*;
103
104mod slicevec;
105pub use slicevec::*;
106
107#[cfg(feature = "alloc")]
108mod tinyvec;
109#[cfg(feature = "alloc")]
110pub use crate::tinyvec::*;