-use rustc_serialize::{Encodable, Decodable, Encoder, Decoder};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+use std::fmt;
use std::fmt::Debug;
+use std::hash::Hash;
use std::iter::{self, FromIterator};
-use std::slice;
use std::marker::PhantomData;
use std::ops::{Index, IndexMut, Range, RangeBounds};
-use std::fmt;
-use std::hash::Hash;
-use std::vec;
+use std::slice;
use std::u32;
+use std::vec;
/// Represents some newtyped `usize` wrapper.
///
impl Idx for usize {
#[inline]
- fn new(idx: usize) -> Self { idx }
+ fn new(idx: usize) -> Self {
+ idx
+ }
#[inline]
- fn index(self) -> usize { self }
+ fn index(self) -> usize {
+ self
+ }
}
impl Idx for u32 {
#[inline]
- fn new(idx: usize) -> Self { assert!(idx <= u32::MAX as usize); idx as u32 }
+ fn new(idx: usize) -> Self {
+ assert!(idx <= u32::MAX as usize);
+ idx as u32
+ }
#[inline]
- fn index(self) -> usize { self as usize }
+ fn index(self) -> usize {
+ self as usize
+ }
}
/// Creates a struct type `S` that can be used as an index with
impl $type {
$v const MAX_AS_U32: u32 = $max;
- $v const MAX: $type = $type::from_u32_const($max);
+ $v const MAX: Self = Self::from_u32_const($max);
#[inline]
$v fn from_usize(value: usize) -> Self {
assert!(value <= ($max as usize));
unsafe {
- $type::from_u32_unchecked(value as u32)
+ Self::from_u32_unchecked(value as u32)
}
}
$v fn from_u32(value: u32) -> Self {
assert!(value <= $max);
unsafe {
- $type::from_u32_unchecked(value)
+ Self::from_u32_unchecked(value)
}
}
];
unsafe {
- $type { private: value }
+ Self { private: value }
}
}
#[inline]
$v const unsafe fn from_u32_unchecked(value: u32) -> Self {
- $type { private: value }
+ Self { private: value }
}
/// Extracts the value of this index as an integer.
type Output = Self;
fn add(self, other: usize) -> Self {
- Self::new(self.index() + other)
+ Self::from_usize(self.index() + other)
}
}
- impl Idx for $type {
+ impl $crate::vec::Idx for $type {
#[inline]
fn new(value: usize) -> Self {
- Self::from(value)
+ Self::from_usize(value)
}
#[inline]
#[inline]
fn steps_between(start: &Self, end: &Self) -> Option<usize> {
<usize as ::std::iter::Step>::steps_between(
- &Idx::index(*start),
- &Idx::index(*end),
+ &Self::index(*start),
+ &Self::index(*end),
)
}
#[inline]
fn replace_one(&mut self) -> Self {
- ::std::mem::replace(self, Self::new(1))
+ ::std::mem::replace(self, Self::from_u32(1))
}
#[inline]
fn replace_zero(&mut self) -> Self {
- ::std::mem::replace(self, Self::new(0))
+ ::std::mem::replace(self, Self::from_u32(0))
}
#[inline]
fn add_one(&self) -> Self {
- Self::new(Idx::index(*self) + 1)
+ Self::from_usize(Self::index(*self) + 1)
}
#[inline]
fn sub_one(&self) -> Self {
- Self::new(Idx::index(*self) - 1)
+ Self::from_usize(Self::index(*self) - 1)
}
#[inline]
fn add_usize(&self, u: usize) -> Option<Self> {
- Idx::index(*self).checked_add(u).map(Self::new)
+ Self::index(*self).checked_add(u).map(Self::from_usize)
}
#[inline]
fn sub_usize(&self, u: usize) -> Option<Self> {
- Idx::index(*self).checked_sub(u).map(Self::new)
+ Self::index(*self).checked_sub(u).map(Self::from_usize)
}
}
impl From<usize> for $type {
#[inline]
fn from(value: usize) -> Self {
- $type::from_usize(value)
+ Self::from_usize(value)
}
}
impl From<u32> for $type {
#[inline]
fn from(value: u32) -> Self {
- $type::from_u32(value)
+ Self::from_u32(value)
}
}
(@decodable $type:ident) => (
impl ::rustc_serialize::Decodable for $type {
fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
- d.read_u32().map(Self::from)
+ d.read_u32().map(Self::from_u32)
}
}
);
const $name:ident = $constant:expr,
$($tokens:tt)*) => (
$(#[doc = $doc])*
- pub const $name: $type = $type::from_u32_const($constant);
+ $v const $name: $type = $type::from_u32_const($constant);
$crate::newtype_index!(
@derives [$($derives,)*]
@attrs [$(#[$attrs])*]
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct IndexVec<I: Idx, T> {
pub raw: Vec<T>,
- _marker: PhantomData<fn(&I)>
+ _marker: PhantomData<fn(&I)>,
}
// Whether `IndexVec` is `Send` depends only on the data,
impl<I: Idx, T: Decodable> Decodable for IndexVec<I, T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
- Decodable::decode(d).map(|v| {
- IndexVec { raw: v, _marker: PhantomData }
- })
+ Decodable::decode(d).map(|v| IndexVec { raw: v, _marker: PhantomData })
}
}
#[inline]
pub fn from_elem<S>(elem: T, universe: &IndexVec<I, S>) -> Self
- where T: Clone
+ where
+ T: Clone,
{
IndexVec { raw: vec![elem; universe.len()], _marker: PhantomData }
}
#[inline]
pub fn from_elem_n(elem: T, n: usize) -> Self
- where T: Clone
+ where
+ T: Clone,
{
IndexVec { raw: vec![elem; n], _marker: PhantomData }
}
}
#[inline]
- pub fn into_iter_enumerated(self) -> Enumerated<I, vec::IntoIter<T>>
- {
+ pub fn into_iter_enumerated(self) -> Enumerated<I, vec::IntoIter<T>> {
self.raw.into_iter().enumerate().map(IntoIdx { _marker: PhantomData })
}
}
#[inline]
- pub fn iter_enumerated(&self) -> Enumerated<I, slice::Iter<'_, T>>
- {
+ pub fn iter_enumerated(&self) -> Enumerated<I, slice::Iter<'_, T>> {
self.raw.iter().enumerate().map(IntoIdx { _marker: PhantomData })
}
}
#[inline]
- pub fn iter_enumerated_mut(&mut self) -> Enumerated<I, slice::IterMut<'_, T>>
- {
+ pub fn iter_enumerated_mut(&mut self) -> Enumerated<I, slice::IterMut<'_, T>> {
self.raw.iter_mut().enumerate().map(IntoIdx { _marker: PhantomData })
}
#[inline]
pub fn drain<'a, R: RangeBounds<usize>>(
- &'a mut self, range: R) -> impl Iterator<Item=T> + 'a {
+ &'a mut self,
+ range: R,
+ ) -> impl Iterator<Item = T> + 'a {
self.raw.drain(range)
}
#[inline]
pub fn drain_enumerated<'a, R: RangeBounds<usize>>(
- &'a mut self, range: R) -> impl Iterator<Item=(I, T)> + 'a {
+ &'a mut self,
+ range: R,
+ ) -> impl Iterator<Item = (I, T)> + 'a {
self.raw.drain(range).enumerate().map(IntoIdx { _marker: PhantomData })
}
}
pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T> {
- IndexVec {
- raw: self.raw,
- _marker: PhantomData,
- }
+ IndexVec { raw: self.raw, _marker: PhantomData }
}
}
impl<I: Idx, T> FromIterator<T> for IndexVec<I, T> {
#[inline]
- fn from_iter<J>(iter: J) -> Self where J: IntoIterator<Item=T> {
+ fn from_iter<J>(iter: J) -> Self
+ where
+ J: IntoIterator<Item = T>,
+ {
IndexVec { raw: FromIterator::from_iter(iter), _marker: PhantomData }
}
}
fn into_iter(self) -> vec::IntoIter<T> {
self.raw.into_iter()
}
-
}
impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T> {
}
}
-pub struct IntoIdx<I: Idx> { _marker: PhantomData<fn(&I)> }
+pub struct IntoIdx<I: Idx> {
+ _marker: PhantomData<fn(&I)>,
+}
impl<I: Idx, T> FnOnce<((usize, T),)> for IntoIdx<I> {
type Output = (I, T);
I::new(n)
}
}
+
+#[cfg(test)]
+mod tests;