1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! This crate provides the
//! [`CalfVec`](https://docs.rs/calf-vec/latest/calf_vec/generic/struct.CalfVec.html)
//! data structure for small copy-on-write arrays.
//! As long as the data is not written to, it is only borrowed.
//! When owned, the data is stored on the stack as long as it is small enough.
//! Data is only moved on the heap as a last resort.
//! This is basically the intersection between
//! [`SmallVec`](https://crates.io/crates/smallvec) and
//! [`Cow`](https://doc.rust-lang.org/std/borrow/enum.Cow.html) (`Small` + `Cow` = `Calf`).
//! Additionally this crate provides a
//! [`CalfString`](https://docs.rs/calf-vec/latest/calf_vec/string/struct.CalfString.html)
//! for small copy-on-write strings
//! based on `CalfVec`.
//!
//! ## Basic usage
//!
//! A `CalfVec` either borrows or owns its data.
//! You can start by creating a `CalfVec` from a slice.
//! It will only be copied when the `CalfVec` is modified.
//! ```rust
//! use calf_vec::CalfVec;
//!
//! let slice = &[1, 2, 3];
//! let mut calf: CalfVec<'_, u8, 32> = CalfVec::borrowed(slice); // at this point, data is only borrowed.
//! calf[0]; // => 1
//! calf[0] = 4; // because it is modified, the data is copied here.
//! assert_eq!(calf, [4, 2, 3])
//! ```
//!
//! A `CalfVec` can also be directly created to own its data:
//! ```rust
//! # use calf_vec::CalfVec;
//! let mut owned: CalfVec<'_, u8, 32> = CalfVec::owned(vec![1, 2, 3]);
//! ```
//! Here, since the owned buffer's capacity is smaller than 32 (given as parameter),
//! it is stored on the stack.
//! It will be moved on the heap only when necessary:
//! ```rust
//! # use calf_vec::CalfVec;
//! # let mut owned: CalfVec<'_, u8, 32> = CalfVec::owned(vec![1, 2, 3]);
//! owned.push(4);
//! owned.push(5);
//! // ...
//! owned.push(31);
//! owned.push(32); // <- here the buffer's capacity now exceeds the given limit (32).
//!                 //    it is hence moved on the heap, transparently.
//! ```

#![feature(min_const_generics)]
#![feature(untagged_unions)]
#![feature(vec_into_raw_parts)]
#![feature(slice_partition_dedup)]
#![feature(shrink_to)]

pub mod generic;
pub mod string;
pub mod wide;
#[cfg(target_pointer_width = "64")]
pub mod lean;
#[cfg(not(target_pointer_width = "64"))]
pub mod lean {
	/// Re-exports `wide` for non-64-bit targets
	pub use super::wide::*;
}

pub use wide::{
	CalfVec,
	CalfString
};