# inline-array `InlineArray` is a stack-inlinable array of bytes that is intended for situations where many bytes are being shared in database-like scenarios, where optimizing for space usage is extremely important. `InlineArray` uses 8 bytes on the stack. It will inline arrays of up to 7 bytes. If the bytes are longer than that, it will store them in an optimized reference-count-backed structure of two different variants. For arrays up to length 255, the data is stored with an `AtomicU8` reference counter and `u8` length field, for only two bytes of overhead. For values larger than that, they are stored with an `AtomicU16` reference counter and a 48-bit length field. If the maximum counter is reached for either variant, the bytes are copied into a new `InlineArray` with a fresh reference count of 1. This is made with the assumption that most reference counts will be far lower than 2^16 and only rarely surpassing 255 in the small case. The inline and both types of shared instances of `InlineArray` guarantee that the stored array is always aligned to 8-byte boundaries, regardless of if it is inline on the stack or shared on the heap. This is advantageous for using in combination with certain zero-copy serialization techniques that require alignment guarantees. Byte arrays that require more than 48 bits to store their length (256 terabytes) are not supported. `InlineArray::make_mut` can be used for getting a mutable reference to the bytes in this structure. If the shared reference counter is higher than 1, this acts like a `Cow` and will make self into a private copy that is safe for modification. # Features * `serde` implements `serde::Serialize` and `serde::Deserialize` for `InlineArray` (disabled by default) # Examples ```rust use inline_array::InlineArray; let ia = InlineArray::from(b"yo!"); // then use it more or less like you would an Arc<[u8]> ```