pub mod index1;
pub mod numeric;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
use core::ops::{Index, IndexMut};
use self::index1::Index1;
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(transparent))]
pub struct Vec1<T> {
pub(crate) inner: Vec<T>,
}
impl<T> Vec1<T> {
#[inline]
pub fn new() -> Self {
Self { inner: Vec::new() }
}
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Self { inner: Vec::with_capacity(capacity) }
}
#[inline]
pub fn len(&self) -> usize {
self.inner.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
#[inline]
pub fn capacity(&self) -> usize {
self.inner.capacity()
}
#[inline]
pub fn push(&mut self, value: T) {
self.inner.push(value);
}
#[inline]
pub fn pop(&mut self) -> Option<T> {
self.inner.pop()
}
#[inline]
pub fn clear(&mut self) {
self.inner.clear();
}
pub fn insert(&mut self, index: usize, value: T) {
let pos = index
.checked_sub(1)
.unwrap_or_else(|| panic!("insertion index (is {index}) should be >= 1"));
self.inner.insert(pos, value);
}
pub fn remove(&mut self, index: usize) -> T {
let pos = index
.checked_sub(1)
.unwrap_or_else(|| panic!("removal index (is {index}) should be >= 1"));
self.inner.remove(pos)
}
#[inline]
pub fn reverse(&mut self) {
self.inner.reverse();
}
pub fn reversed(&self) -> Self
where
T: Clone,
{
let mut inner = self.inner.clone();
inner.reverse();
Self { inner }
}
#[inline]
pub fn get(&self, index: usize) -> Option<&T> {
index.checked_sub(1).and_then(|pos| self.inner.get(pos))
}
#[inline]
pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
index.checked_sub(1).and_then(|pos| self.inner.get_mut(pos))
}
#[inline]
pub fn get_index1(&self, index: Index1) -> Option<&T> {
self.get(index.get())
}
#[inline]
pub fn get_index1_mut(&mut self, index: Index1) -> Option<&mut T> {
self.get_mut(index.get())
}
#[inline]
pub fn first(&self) -> Option<&T> {
self.inner.first()
}
#[inline]
pub fn first_mut(&mut self) -> Option<&mut T> {
self.inner.first_mut()
}
#[inline]
pub fn last(&self) -> Option<&T> {
self.inner.last()
}
#[inline]
pub fn last_mut(&mut self) -> Option<&mut T> {
self.inner.last_mut()
}
#[inline]
pub fn iter(&self) -> core::slice::Iter<'_, T> {
self.inner.iter()
}
#[inline]
pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
self.inner.iter_mut()
}
#[inline]
pub fn iter_indexed(&self) -> impl Iterator<Item = (usize, &T)> + '_ {
self.inner.iter().enumerate().map(|(i, v)| (i + 1, v))
}
#[inline]
pub fn indices(&self) -> core::ops::RangeInclusive<usize> {
1..=self.len()
}
#[inline]
pub fn as_slice(&self) -> &[T] {
&self.inner
}
#[inline]
pub fn as_mut_slice(&mut self) -> &mut [T] {
self.inner.as_mut_slice()
}
#[inline]
pub fn as_vec(&self) -> &Vec<T> {
&self.inner
}
#[inline]
pub fn reserve(&mut self, additional: usize) {
self.inner.reserve(additional);
}
#[inline]
pub fn shrink_to_fit(&mut self) {
self.inner.shrink_to_fit();
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self.inner.as_mut_ptr()
}
}
impl<T: Clone> Vec1<T> {
pub fn replace(&mut self, index: usize, value: T) -> T {
let pos = index
.checked_sub(1)
.unwrap_or_else(|| panic!("replacement index (is {index}) should be >= 1"));
core::mem::replace(&mut self.inner[pos], value)
}
}
impl<T> From<Vec<T>> for Vec1<T> {
#[inline]
fn from(v: Vec<T>) -> Self {
Self { inner: v }
}
}
impl<T> From<Vec1<T>> for Vec<T> {
#[inline]
fn from(v: Vec1<T>) -> Self {
v.inner
}
}
impl<T> FromIterator<T> for Vec1<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
Self { inner: iter.into_iter().collect() }
}
}
impl<T> Extend<T> for Vec1<T> {
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
self.inner.extend(iter);
}
}
impl<T> Index<usize> for Vec1<T> {
type Output = T;
#[inline]
fn index(&self, index: usize) -> &Self::Output {
self.get(index).unwrap_or_else(|| {
panic!(
"index out of bounds: the len is {} but the index is {index} (one-based: valid range is 1..={})",
self.len(),
self.len()
)
})
}
}
impl<T> IndexMut<usize> for Vec1<T> {
#[inline]
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
let len = self.len();
self.get_mut(index).unwrap_or_else(|| {
panic!(
"index out of bounds: the len is {len} but the index is {index} (one-based: valid range is 1..={len})"
)
})
}
}
impl<T> Index<Index1> for Vec1<T> {
type Output = T;
#[inline]
fn index(&self, index: Index1) -> &Self::Output {
&self[index.get()]
}
}
impl<T> IndexMut<Index1> for Vec1<T> {
#[inline]
fn index_mut(&mut self, index: Index1) -> &mut Self::Output {
&mut self[index.get()]
}
}
#[macro_export]
macro_rules! vec1 {
() => { $crate::Vec1::new() };
($elem:expr; $n:expr) => {{
let n = $n;
let mut v = $crate::Vec1::with_capacity(n);
for _ in 0..n {
v.push($elem.clone());
}
v
}};
($($x:expr),+ $(,)?) => {{
let mut v = $crate::Vec1::new();
$( v.push($x); )*
v
}};
}
#[deprecated(
since = "0.2.0",
note = "use `Vec1` instead; `VecIndexFromOne` will be removed in 1.0"
)]
pub type VecIndexFromOne<T> = Vec1<T>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_is_empty() {
let v: Vec1<i32> = Vec1::new();
assert!(v.is_empty());
assert_eq!(v.len(), 0);
}
#[test]
fn indexing_is_one_based() {
let v = Vec1::from(vec![10, 20, 30]);
assert_eq!(v[1], 10);
assert_eq!(v[2], 20);
assert_eq!(v[3], 30);
}
#[test]
fn get_zero_returns_none() {
let v = Vec1::from(vec![1, 2, 3]);
assert_eq!(v.get(0), None);
assert_eq!(v.get(4), None);
}
#[test]
#[should_panic(expected = "one-based: valid range is 1..=")]
fn index_zero_panics() {
let v = Vec1::from(vec![1, 2, 3]);
let _ = v[0];
}
#[test]
#[should_panic(expected = "index out of bounds")]
fn index_oob_panics() {
let v = Vec1::from(vec![1, 2, 3]);
let _ = v[4];
}
#[test]
fn push_pop() {
let mut v = Vec1::new();
v.push(1);
v.push(2);
assert_eq!(v.len(), 2);
assert_eq!(v.pop(), Some(2));
assert_eq!(v.pop(), Some(1));
assert_eq!(v.pop(), None);
}
#[test]
fn insert_remove() {
let mut v = Vec1::from(vec![2, 3]);
v.insert(1, 1);
assert_eq!(v.as_slice(), &[1, 2, 3]);
let removed = v.remove(2);
assert_eq!(removed, 2);
assert_eq!(v.as_slice(), &[1, 3]);
}
#[test]
fn iter_indexed_starts_at_one() {
let v = Vec1::from(vec![10, 20, 30]);
let pairs: Vec<_> = v.iter_indexed().collect();
assert_eq!(pairs, vec![(1, &10), (2, &20), (3, &30)]);
}
#[test]
fn indices_are_one_to_len() {
let v = Vec1::from(vec![10, 20, 30]);
let idx: Vec<_> = v.indices().collect();
assert_eq!(idx, vec![1, 2, 3]);
}
#[test]
fn reverse_and_reversed() {
let mut v = Vec1::from(vec![1, 2, 3]);
let r = v.reversed();
assert_eq!(r.as_slice(), &[3, 2, 1]);
assert_eq!(v.as_slice(), &[1, 2, 3]);
v.reverse();
assert_eq!(v.as_slice(), &[3, 2, 1]);
}
#[test]
fn index1_type_safe() {
let v = Vec1::from(vec![10, 20, 30]);
assert_eq!(v[Index1::new(2)], 20);
assert_eq!(v.get_index1(Index1::new(3)), Some(&30));
assert_eq!(v.get_index1(Index1::new(0)), None);
}
#[test]
fn vec1_macro_multiple() {
let v = vec1![1, 2, 3, 4, 5];
assert_eq!(v.len(), 5);
assert_eq!(v[1], 1);
assert_eq!(v[5], 5);
}
#[test]
fn vec1_macro_empty() {
let v: Vec1<i32> = vec1![];
assert!(v.is_empty());
}
#[test]
fn vec1_macro_repeat() {
let v = vec1![0.0; 5];
assert_eq!(v.len(), 5);
assert_eq!(v[1], 0.0);
assert_eq!(v[5], 0.0);
}
#[test]
fn from_into_vec_roundtrip() {
let v: Vec1<i32> = vec![1, 2].into();
let back: Vec<i32> = v.into();
assert_eq!(back, vec![1, 2]);
}
#[test]
fn collect_from_iterator() {
let v: Vec1<i32> = (1..=5).collect();
assert_eq!(v.len(), 5);
assert_eq!(v[1], 1);
assert_eq!(v[5], 5);
}
#[test]
#[allow(deprecated)]
fn deprecated_alias_works() {
let v = VecIndexFromOne::from(vec![1, 2, 3]);
assert_eq!(v[1], 1);
}
}