From 1d103cf087c574f66279490ffef8c76178aea5cc Mon Sep 17 00:00:00 2001 From: Aramis Razzaghipour Date: Fri, 15 Jan 2021 11:02:08 +1100 Subject: =?UTF-8?q?Use=20=E2=80=98index=E2=80=99=20terminology=20for=20are?= =?UTF-8?q?na=20consistently?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/arena/src/lib.rs | 58 ++++++++++++++++++++++++++-------------------------- lib/arena/src/map.rs | 37 ++++++++++++++++++--------------- 2 files changed, 49 insertions(+), 46 deletions(-) (limited to 'lib') diff --git a/lib/arena/src/lib.rs b/lib/arena/src/lib.rs index 1de3a1d2f..230a50291 100644 --- a/lib/arena/src/lib.rs +++ b/lib/arena/src/lib.rs @@ -1,4 +1,4 @@ -//! Yet another ID-based arena. +//! Yet another index-based arena. #![warn(missing_docs)] @@ -13,37 +13,37 @@ use std::{ mod map; pub use map::ArenaMap; -/// The raw ID of a value in an arena. +/// The raw index of a value in an arena. #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct RawId(u32); +pub struct RawIdx(u32); -impl From for u32 { - fn from(raw: RawId) -> u32 { +impl From for u32 { + fn from(raw: RawIdx) -> u32 { raw.0 } } -impl From for RawId { - fn from(id: u32) -> RawId { - RawId(id) +impl From for RawIdx { + fn from(idx: u32) -> RawIdx { + RawIdx(idx) } } -impl fmt::Debug for RawId { +impl fmt::Debug for RawIdx { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f) } } -impl fmt::Display for RawId { +impl fmt::Display for RawIdx { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f) } } -/// The ID of a value allocated in an arena that holds `T`s. +/// The index of a value allocated in an arena that holds `T`s. pub struct Idx { - raw: RawId, + raw: RawIdx, _ty: PhantomData T>, } @@ -78,18 +78,18 @@ impl fmt::Debug for Idx { } impl Idx { - /// Creates a new ID from a [`RawId`]. - pub fn from_raw(raw: RawId) -> Self { + /// Creates a new index from a [`RawIdx`]. + pub fn from_raw(raw: RawIdx) -> Self { Idx { raw, _ty: PhantomData } } - /// Converts this ID into the underlying [`RawId`]. - pub fn into_raw(self) -> RawId { + /// Converts this index into the underlying [`RawIdx`]. + pub fn into_raw(self) -> RawIdx { self.raw } } -/// Yet another ID-based arena. +/// Yet another index-based arena. #[derive(Clone, PartialEq, Eq)] pub struct Arena { data: Vec, @@ -161,37 +161,37 @@ impl Arena { self.data.is_empty() } - /// Allocates a new value on the arena, returning the value’s ID. + /// Allocates a new value on the arena, returning the value’s index. /// /// ``` /// let mut arena = la_arena::Arena::new(); - /// let id = arena.alloc(50); + /// let idx = arena.alloc(50); /// - /// assert_eq!(arena[id], 50); + /// assert_eq!(arena[idx], 50); /// ``` pub fn alloc(&mut self, value: T) -> Idx { - let id = RawId(self.data.len() as u32); + let idx = RawIdx(self.data.len() as u32); self.data.push(value); - Idx::from_raw(id) + Idx::from_raw(idx) } /// Returns an iterator over the arena’s elements. /// /// ``` /// let mut arena = la_arena::Arena::new(); - /// let id1 = arena.alloc(20); - /// let id2 = arena.alloc(40); - /// let id3 = arena.alloc(60); + /// 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((id1, &20))); - /// assert_eq!(iterator.next(), Some((id2, &40))); - /// assert_eq!(iterator.next(), Some((id3, &60))); + /// 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 { - self.data.iter().enumerate().map(|(idx, value)| (Idx::from_raw(RawId(idx as u32)), value)) + self.data.iter().enumerate().map(|(idx, value)| (Idx::from_raw(RawIdx(idx as u32)), value)) } /// Reallocates the arena to make it take up as little space as possible. diff --git a/lib/arena/src/map.rs b/lib/arena/src/map.rs index 5ebaa9b82..d8acfe051 100644 --- a/lib/arena/src/map.rs +++ b/lib/arena/src/map.rs @@ -2,30 +2,33 @@ use std::marker::PhantomData; use crate::Idx; -/// A map from arena IDs to some other type. Space requirement is O(highest ID). +/// 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 { +pub struct ArenaMap { v: Vec>, - _ty: PhantomData, + _ty: PhantomData, } impl ArenaMap, V> { - /// Inserts a value associated with a given arena ID into the map. - pub fn insert(&mut self, id: Idx, t: V) { - let idx = Self::to_idx(id); + /// Inserts a value associated with a given arena index into the map. + pub fn insert(&mut self, idx: Idx, t: V) { + let idx = Self::to_idx(idx); self.v.resize_with((idx + 1).max(self.v.len()), || None); self.v[idx] = Some(t); } - /// Returns a reference to the value associated with the provided ID if it is present. - pub fn get(&self, id: Idx) -> Option<&V> { - self.v.get(Self::to_idx(id)).and_then(|it| it.as_ref()) + /// 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 ID if it is present. - pub fn get_mut(&mut self, id: Idx) -> Option<&mut V> { - self.v.get_mut(Self::to_idx(id)).and_then(|it| it.as_mut()) + /// 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. @@ -38,13 +41,13 @@ impl ArenaMap, V> { self.v.iter_mut().filter_map(|o| o.as_mut()) } - /// Returns an iterator over the arena IDs and values in the map. + /// Returns an iterator over the arena indexes and values in the map. pub fn iter(&self) -> impl Iterator, &V)> { self.v.iter().enumerate().filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_ref()?))) } - fn to_idx(id: Idx) -> usize { - u32::from(id.into_raw()) as usize + fn to_idx(idx: Idx) -> usize { + u32::from(idx.into_raw()) as usize } fn from_idx(idx: usize) -> Idx { @@ -54,8 +57,8 @@ impl ArenaMap, V> { impl std::ops::Index> for ArenaMap, T> { type Output = T; - fn index(&self, id: Idx) -> &T { - self.v[Self::to_idx(id)].as_ref().unwrap() + fn index(&self, idx: Idx) -> &T { + self.v[Self::to_idx(idx)].as_ref().unwrap() } } -- cgit v1.2.3