la-arena-0.3.1/Cargo.toml0000644000000015250000000000100105160ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" rust-version = "1.56" name = "la-arena" version = "0.3.1" description = "Simple index-based arena without deletion." documentation = "https://docs.rs/la-arena" categories = [ "data-structures", "memory-management", "rust-patterns", ] license = "MIT OR Apache-2.0" repository = "https://github.com/rust-lang/rust-analyzer/tree/master/lib/la-arena" la-arena-0.3.1/Cargo.toml.orig000064400000000000000000000005631046102023000142000ustar 00000000000000[package] name = "la-arena" version = "0.3.1" description = "Simple index-based arena without deletion." license = "MIT OR Apache-2.0" repository = "https://github.com/rust-lang/rust-analyzer/tree/master/lib/la-arena" documentation = "https://docs.rs/la-arena" categories = ["data-structures", "memory-management", "rust-patterns"] edition = "2021" rust-version = "1.56" la-arena-0.3.1/src/lib.rs000064400000000000000000000324551046102023000132210ustar 00000000000000//! Yet another index-based arena. #![warn(rust_2018_idioms, unused_lifetimes, semicolon_in_expressions_from_macros)] #![warn(missing_docs)] use std::{ cmp, fmt, hash::{Hash, Hasher}, iter::{Enumerate, FusedIterator}, marker::PhantomData, ops::{Index, IndexMut, Range, RangeInclusive}, }; mod map; pub use map::{ArenaMap, Entry, OccupiedEntry, VacantEntry}; /// The raw index of a value in an arena. #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct RawIdx(u32); impl RawIdx { /// Constructs a [`RawIdx`] from a u32. pub const fn from_u32(u32: u32) -> Self { RawIdx(u32) } /// Deconstructs a [`RawIdx`] into the underlying u32. pub const fn into_u32(self) -> u32 { self.0 } } impl From for u32 { #[inline] fn from(raw: RawIdx) -> u32 { raw.0 } } impl From for RawIdx { #[inline] fn from(idx: u32) -> RawIdx { RawIdx(idx) } } impl fmt::Debug for RawIdx { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) } } impl fmt::Display for RawIdx { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) } } /// The index of a value allocated in an arena that holds `T`s. pub struct Idx { raw: RawIdx, _ty: PhantomData T>, } impl Ord for Idx { fn cmp(&self, other: &Self) -> cmp::Ordering { self.raw.cmp(&other.raw) } } impl PartialOrd for Idx { fn partial_cmp(&self, other: &Self) -> Option { self.raw.partial_cmp(&other.raw) } } impl Clone for Idx { fn clone(&self) -> Self { *self } } impl Copy for Idx {} impl PartialEq for Idx { fn eq(&self, other: &Idx) -> bool { self.raw == other.raw } } impl Eq for Idx {} impl Hash for Idx { fn hash(&self, state: &mut H) { self.raw.hash(state); } } impl fmt::Debug for Idx { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut type_name = std::any::type_name::(); if let Some(idx) = type_name.rfind(':') { type_name = &type_name[idx + 1..]; } write!(f, "Idx::<{}>({})", type_name, self.raw) } } impl Idx { /// Creates a new index from a [`RawIdx`]. pub const fn from_raw(raw: RawIdx) -> Self { Idx { raw, _ty: PhantomData } } /// Converts this index into the underlying [`RawIdx`]. pub const fn into_raw(self) -> RawIdx { self.raw } } /// A range of densely allocated arena values. pub struct IdxRange { range: Range, _p: PhantomData, } impl IdxRange { /// Creates a new index range /// inclusive of the start value and exclusive of the end value. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let a = arena.alloc("a"); /// let b = arena.alloc("b"); /// let c = arena.alloc("c"); /// let d = arena.alloc("d"); /// /// let range = la_arena::IdxRange::new(b..d); /// assert_eq!(&arena[range], &["b", "c"]); /// ``` pub fn new(range: Range>) -> Self { Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData } } /// Creates a new index range /// inclusive of the start value and end value. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let foo = arena.alloc("foo"); /// let bar = arena.alloc("bar"); /// let baz = arena.alloc("baz"); /// /// let range = la_arena::IdxRange::new_inclusive(foo..=baz); /// assert_eq!(&arena[range], &["foo", "bar", "baz"]); /// /// let range = la_arena::IdxRange::new_inclusive(foo..=foo); /// assert_eq!(&arena[range], &["foo"]); /// ``` pub fn new_inclusive(range: RangeInclusive>) -> Self { Self { range: u32::from(range.start().into_raw())..u32::from(range.end().into_raw()) + 1, _p: PhantomData, } } /// Returns whether the index range is empty. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let one = arena.alloc(1); /// let two = arena.alloc(2); /// /// assert!(la_arena::IdxRange::new(one..one).is_empty()); /// ``` pub fn is_empty(&self) -> bool { self.range.is_empty() } /// Returns the start of the index range. pub fn start(&self) -> Idx { Idx::from_raw(RawIdx::from(self.range.start)) } /// Returns the end of the index range. pub fn end(&self) -> Idx { Idx::from_raw(RawIdx::from(self.range.end)) } } impl Iterator for IdxRange { type Item = Idx; fn next(&mut self) -> Option { self.range.next().map(|raw| Idx::from_raw(raw.into())) } fn size_hint(&self) -> (usize, Option) { self.range.size_hint() } fn count(self) -> usize where Self: Sized, { self.range.count() } fn last(self) -> Option where Self: Sized, { self.range.last().map(|raw| Idx::from_raw(raw.into())) } fn nth(&mut self, n: usize) -> Option { self.range.nth(n).map(|raw| Idx::from_raw(raw.into())) } } impl DoubleEndedIterator for IdxRange { fn next_back(&mut self) -> Option { self.range.next_back().map(|raw| Idx::from_raw(raw.into())) } } impl ExactSizeIterator for IdxRange {} impl FusedIterator for IdxRange {} impl fmt::Debug for IdxRange { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple(&format!("IdxRange::<{}>", std::any::type_name::())) .field(&self.range) .finish() } } impl Clone for IdxRange { fn clone(&self) -> Self { Self { range: self.range.clone(), _p: PhantomData } } } impl PartialEq for IdxRange { fn eq(&self, other: &Self) -> bool { self.range == other.range } } impl Eq for IdxRange {} /// Yet another index-based arena. #[derive(Clone, PartialEq, Eq, Hash)] pub struct Arena { data: Vec, } impl fmt::Debug for Arena { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Arena").field("len", &self.len()).field("data", &self.data).finish() } } impl Arena { /// Creates a new empty arena. /// /// ``` /// let arena: la_arena::Arena = la_arena::Arena::new(); /// assert!(arena.is_empty()); /// ``` pub const fn new() -> Arena { Arena { data: Vec::new() } } /// Create a new empty arena with specific capacity. /// /// ``` /// let arena: la_arena::Arena = la_arena::Arena::with_capacity(42); /// assert!(arena.is_empty()); /// ``` pub fn with_capacity(capacity: usize) -> Arena { Arena { data: Vec::with_capacity(capacity) } } /// Empties the arena, removing all contained values. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// /// arena.alloc(1); /// arena.alloc(2); /// arena.alloc(3); /// assert_eq!(arena.len(), 3); /// /// arena.clear(); /// assert!(arena.is_empty()); /// ``` pub fn clear(&mut self) { self.data.clear(); } /// Returns the length of the arena. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// assert_eq!(arena.len(), 0); /// /// arena.alloc("foo"); /// assert_eq!(arena.len(), 1); /// /// arena.alloc("bar"); /// assert_eq!(arena.len(), 2); /// /// arena.alloc("baz"); /// assert_eq!(arena.len(), 3); /// ``` pub fn len(&self) -> usize { self.data.len() } /// Returns whether the arena contains no elements. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// assert!(arena.is_empty()); /// /// arena.alloc(0.5); /// assert!(!arena.is_empty()); /// ``` pub fn is_empty(&self) -> bool { self.data.is_empty() } /// Allocates a new value on the arena, returning the value’s index. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let idx = arena.alloc(50); /// /// assert_eq!(arena[idx], 50); /// ``` pub fn alloc(&mut self, value: T) -> Idx { let idx = self.next_idx(); self.data.push(value); idx } /// Densely allocates multiple values, returning the values’ index range. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let range = arena.alloc_many(0..4); /// /// assert_eq!(arena[range], [0, 1, 2, 3]); /// ``` pub fn alloc_many>(&mut self, iter: II) -> IdxRange { let start = self.next_idx(); self.extend(iter); let end = self.next_idx(); IdxRange::new(start..end) } /// Returns an iterator over the arena’s elements. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let idx1 = arena.alloc(20); /// let idx2 = arena.alloc(40); /// let idx3 = arena.alloc(60); /// /// let mut iterator = arena.iter(); /// assert_eq!(iterator.next(), Some((idx1, &20))); /// assert_eq!(iterator.next(), Some((idx2, &40))); /// assert_eq!(iterator.next(), Some((idx3, &60))); /// ``` pub fn iter( &self, ) -> impl Iterator, &T)> + ExactSizeIterator + DoubleEndedIterator + Clone { self.data.iter().enumerate().map(|(idx, value)| (Idx::from_raw(RawIdx(idx as u32)), value)) } /// Returns an iterator over the arena’s mutable elements. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let idx1 = arena.alloc(20); /// /// assert_eq!(arena[idx1], 20); /// /// let mut iterator = arena.iter_mut(); /// *iterator.next().unwrap().1 = 10; /// drop(iterator); /// /// assert_eq!(arena[idx1], 10); /// ``` pub fn iter_mut( &mut self, ) -> impl Iterator, &mut T)> + ExactSizeIterator + DoubleEndedIterator { self.data .iter_mut() .enumerate() .map(|(idx, value)| (Idx::from_raw(RawIdx(idx as u32)), value)) } /// Returns an iterator over the arena’s values. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let idx1 = arena.alloc(20); /// let idx2 = arena.alloc(40); /// let idx3 = arena.alloc(60); /// /// let mut iterator = arena.values(); /// assert_eq!(iterator.next(), Some(&20)); /// assert_eq!(iterator.next(), Some(&40)); /// assert_eq!(iterator.next(), Some(&60)); /// ``` pub fn values(&self) -> impl Iterator + ExactSizeIterator + DoubleEndedIterator { self.data.iter() } /// Returns an iterator over the arena’s mutable values. /// /// ``` /// let mut arena = la_arena::Arena::new(); /// let idx1 = arena.alloc(20); /// /// assert_eq!(arena[idx1], 20); /// /// let mut iterator = arena.values_mut(); /// *iterator.next().unwrap() = 10; /// drop(iterator); /// /// assert_eq!(arena[idx1], 10); /// ``` pub fn values_mut( &mut self, ) -> impl Iterator + ExactSizeIterator + DoubleEndedIterator { self.data.iter_mut() } /// Reallocates the arena to make it take up as little space as possible. pub fn shrink_to_fit(&mut self) { self.data.shrink_to_fit(); } /// Returns the index of the next value allocated on the arena. /// /// This method should remain private to make creating invalid `Idx`s harder. fn next_idx(&self) -> Idx { Idx::from_raw(RawIdx(self.data.len() as u32)) } } impl AsMut<[T]> for Arena { fn as_mut(&mut self) -> &mut [T] { self.data.as_mut() } } impl Default for Arena { fn default() -> Arena { Arena { data: Vec::new() } } } impl Index> for Arena { type Output = T; fn index(&self, idx: Idx) -> &T { let idx = idx.into_raw().0 as usize; &self.data[idx] } } impl IndexMut> for Arena { fn index_mut(&mut self, idx: Idx) -> &mut T { let idx = idx.into_raw().0 as usize; &mut self.data[idx] } } impl Index> for Arena { type Output = [T]; fn index(&self, range: IdxRange) -> &[T] { let start = range.range.start as usize; let end = range.range.end as usize; &self.data[start..end] } } impl FromIterator for Arena { fn from_iter(iter: I) -> Self where I: IntoIterator, { Arena { data: Vec::from_iter(iter) } } } /// An iterator over the arena’s elements. pub struct IntoIter(Enumerate< as IntoIterator>::IntoIter>); impl Iterator for IntoIter { type Item = (Idx, T); fn next(&mut self) -> Option { self.0.next().map(|(idx, value)| (Idx::from_raw(RawIdx(idx as u32)), value)) } } impl IntoIterator for Arena { type Item = (Idx, T); type IntoIter = IntoIter; fn into_iter(self) -> Self::IntoIter { IntoIter(self.data.into_iter().enumerate()) } } impl Extend for Arena { fn extend>(&mut self, iter: II) { for t in iter { self.alloc(t); } } } la-arena-0.3.1/src/map.rs000064400000000000000000000226261046102023000132270ustar 00000000000000use std::iter::Enumerate; use std::marker::PhantomData; use crate::Idx; /// A map from arena indexes to some other type. /// Space requirement is O(highest index). #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ArenaMap { v: Vec>, _ty: PhantomData, } impl ArenaMap, V> { /// Creates a new empty map. pub const fn new() -> Self { Self { v: Vec::new(), _ty: PhantomData } } /// Create a new empty map with specific capacity. pub fn with_capacity(capacity: usize) -> Self { Self { v: Vec::with_capacity(capacity), _ty: PhantomData } } /// Reserves capacity for at least additional more elements to be inserted in the map. pub fn reserve(&mut self, additional: usize) { self.v.reserve(additional); } /// Clears the map, removing all elements. pub fn clear(&mut self) { self.v.clear(); } /// Shrinks the capacity of the map as much as possible. pub fn shrink_to_fit(&mut self) { let min_len = self.v.iter().rposition(|slot| slot.is_some()).map_or(0, |i| i + 1); self.v.truncate(min_len); self.v.shrink_to_fit(); } /// Returns whether the map contains a value for the specified index. pub fn contains_idx(&self, idx: Idx) -> bool { matches!(self.v.get(Self::to_idx(idx)), Some(Some(_))) } /// Removes an index from the map, returning the value at the index if the index was previously in the map. pub fn remove(&mut self, idx: Idx) -> Option { self.v.get_mut(Self::to_idx(idx))?.take() } /// Inserts a value associated with a given arena index into the map. /// /// If the map did not have this index present, None is returned. /// Otherwise, the value is updated, and the old value is returned. pub fn insert(&mut self, idx: Idx, t: V) -> Option { let idx = Self::to_idx(idx); self.v.resize_with((idx + 1).max(self.v.len()), || None); self.v[idx].replace(t) } /// Returns a reference to the value associated with the provided index /// if it is present. pub fn get(&self, idx: Idx) -> Option<&V> { self.v.get(Self::to_idx(idx)).and_then(|it| it.as_ref()) } /// Returns a mutable reference to the value associated with the provided index /// if it is present. pub fn get_mut(&mut self, idx: Idx) -> Option<&mut V> { self.v.get_mut(Self::to_idx(idx)).and_then(|it| it.as_mut()) } /// Returns an iterator over the values in the map. pub fn values(&self) -> impl Iterator + DoubleEndedIterator { self.v.iter().filter_map(|o| o.as_ref()) } /// Returns an iterator over mutable references to the values in the map. pub fn values_mut(&mut self) -> impl Iterator + DoubleEndedIterator { self.v.iter_mut().filter_map(|o| o.as_mut()) } /// Returns an iterator over the arena indexes and values in the map. pub fn iter(&self) -> impl Iterator, &V)> + DoubleEndedIterator { self.v.iter().enumerate().filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_ref()?))) } /// Returns an iterator over the arena indexes and values in the map. pub fn iter_mut(&mut self) -> impl Iterator, &mut V)> { self.v .iter_mut() .enumerate() .filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_mut()?))) } /// Gets the given key's corresponding entry in the map for in-place manipulation. pub fn entry(&mut self, idx: Idx) -> Entry<'_, Idx, V> { let idx = Self::to_idx(idx); self.v.resize_with((idx + 1).max(self.v.len()), || None); match &mut self.v[idx] { slot @ Some(_) => Entry::Occupied(OccupiedEntry { slot, _ty: PhantomData }), slot @ None => Entry::Vacant(VacantEntry { slot, _ty: PhantomData }), } } fn to_idx(idx: Idx) -> usize { u32::from(idx.into_raw()) as usize } fn from_idx(idx: usize) -> Idx { Idx::from_raw((idx as u32).into()) } } impl std::ops::Index> for ArenaMap, T> { type Output = T; fn index(&self, idx: Idx) -> &T { self.v[Self::to_idx(idx)].as_ref().unwrap() } } impl std::ops::IndexMut> for ArenaMap, T> { fn index_mut(&mut self, idx: Idx) -> &mut T { self.v[Self::to_idx(idx)].as_mut().unwrap() } } impl Default for ArenaMap, T> { fn default() -> Self { Self::new() } } impl Extend<(Idx, T)> for ArenaMap, T> { fn extend, T)>>(&mut self, iter: I) { iter.into_iter().for_each(move |(k, v)| { self.insert(k, v); }); } } impl FromIterator<(Idx, T)> for ArenaMap, T> { fn from_iter, T)>>(iter: I) -> Self { let mut this = Self::new(); this.extend(iter); this } } pub struct ArenaMapIter { iter: Enumerate>>, _ty: PhantomData, } impl IntoIterator for ArenaMap, V> { type Item = (Idx, V); type IntoIter = ArenaMapIter, V>; fn into_iter(self) -> Self::IntoIter { let iter = self.v.into_iter().enumerate(); Self::IntoIter { iter, _ty: PhantomData } } } impl ArenaMapIter, V> { fn mapper((idx, o): (usize, Option)) -> Option<(Idx, V)> { Some((ArenaMap::, V>::from_idx(idx), o?)) } } impl Iterator for ArenaMapIter, V> { type Item = (Idx, V); #[inline] fn next(&mut self) -> Option { for next in self.iter.by_ref() { match Self::mapper(next) { Some(r) => return Some(r), None => continue, } } None } #[inline] fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } impl DoubleEndedIterator for ArenaMapIter, V> { #[inline] fn next_back(&mut self) -> Option { while let Some(next_back) = self.iter.next_back() { match Self::mapper(next_back) { Some(r) => return Some(r), None => continue, } } None } } /// A view into a single entry in a map, which may either be vacant or occupied. /// /// This `enum` is constructed from the [`entry`] method on [`ArenaMap`]. /// /// [`entry`]: ArenaMap::entry pub enum Entry<'a, IDX, V> { /// A vacant entry. Vacant(VacantEntry<'a, IDX, V>), /// An occupied entry. Occupied(OccupiedEntry<'a, IDX, V>), } impl<'a, IDX, V> Entry<'a, IDX, V> { /// Ensures a value is in the entry by inserting the default if empty, and returns a mutable reference to /// the value in the entry. pub fn or_insert(self, default: V) -> &'a mut V { match self { Self::Vacant(ent) => ent.insert(default), Self::Occupied(ent) => ent.into_mut(), } } /// Ensures a value is in the entry by inserting the result of the default function if empty, and returns /// a mutable reference to the value in the entry. pub fn or_insert_with V>(self, default: F) -> &'a mut V { match self { Self::Vacant(ent) => ent.insert(default()), Self::Occupied(ent) => ent.into_mut(), } } /// Provides in-place mutable access to an occupied entry before any potential inserts into the map. pub fn and_modify(mut self, f: F) -> Self { if let Self::Occupied(ent) = &mut self { f(ent.get_mut()); } self } } impl<'a, IDX, V> Entry<'a, IDX, V> where V: Default, { /// Ensures a value is in the entry by inserting the default value if empty, and returns a mutable reference /// to the value in the entry. pub fn or_default(self) -> &'a mut V { self.or_insert_with(Default::default) } } /// A view into an vacant entry in a [`ArenaMap`]. It is part of the [`Entry`] enum. pub struct VacantEntry<'a, IDX, V> { slot: &'a mut Option, _ty: PhantomData, } impl<'a, IDX, V> VacantEntry<'a, IDX, V> { /// Sets the value of the entry with the `VacantEntry`’s key, and returns a mutable reference to it. pub fn insert(self, value: V) -> &'a mut V { self.slot.insert(value) } } /// A view into an occupied entry in a [`ArenaMap`]. It is part of the [`Entry`] enum. pub struct OccupiedEntry<'a, IDX, V> { slot: &'a mut Option, _ty: PhantomData, } impl<'a, IDX, V> OccupiedEntry<'a, IDX, V> { /// Gets a reference to the value in the entry. pub fn get(&self) -> &V { self.slot.as_ref().expect("Occupied") } /// Gets a mutable reference to the value in the entry. pub fn get_mut(&mut self) -> &mut V { self.slot.as_mut().expect("Occupied") } /// Converts the entry into a mutable reference to its value. pub fn into_mut(self) -> &'a mut V { self.slot.as_mut().expect("Occupied") } /// Sets the value of the entry with the `OccupiedEntry`’s key, and returns the entry’s old value. pub fn insert(&mut self, value: V) -> V { self.slot.replace(value).expect("Occupied") } /// Takes the value of the entry out of the map, and returns it. pub fn remove(self) -> V { self.slot.take().expect("Occupied") } }