Quaternions/arrayvec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #137 from bluss/various

Browse Source 
Combined fixes: Adjust inlining, and Fix usage of `get_unchecked_mut`.
This commit is contained in:
bluss
2019-10-09 10:47:21 +02:00
committed by GitHub
parent 2a376d966d fd72321191
commit b7b8cf8777
3 changed files with 15 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/array.rs
-2
View File
@@ -87,10 +87,8 @@ macro_rules! fix_array_impl {
type Index = $index_type;
const CAPACITY: usize = $len;
#[doc(hidden)]
#[inline]
fn as_slice(&self) -> &[Self::Item] { self }
#[doc(hidden)]
#[inline]
fn as_mut_slice(&mut self) -> &mut [Self::Item] { self }
}
)
src/array_string.rs
+1 -5
View File
@@ -113,7 +113,7 @@ impl<A> ArrayString<A>
/// let string = ArrayString::<[_; 3]>::new();
/// assert_eq!(string.capacity(), 3);
/// ```
#[inline]
#[inline(always)]
pub fn capacity(&self) -> usize { A::CAPACITY }
/// Return if the `ArrayString` is completely filled.
@@ -244,7 +244,6 @@ impl<A> ArrayString<A>
///
/// assert_eq!(s.pop(), None);
/// ```
#[inline]
pub fn pop(&mut self) -> Option<char> {
let ch = match self.chars().rev().next() {
Some(ch) => ch,
@@ -273,7 +272,6 @@ impl<A> ArrayString<A>
/// string.truncate(4);
/// assert_eq!(&string[..], "foo");
/// ```
#[inline]
pub fn truncate(&mut self, new_len: usize) {
if new_len <= self.len() {
assert!(self.is_char_boundary(new_len));
@@ -304,7 +302,6 @@ impl<A> ArrayString<A>
/// assert_eq!(s.remove(1), 'o');
/// assert_eq!(s.remove(0), 'o');
/// ```
#[inline]
pub fn remove(&mut self, idx: usize) -> char {
let ch = match self[idx..].chars().next() {
Some(ch) => ch,
@@ -336,7 +333,6 @@ impl<A> ArrayString<A>
///
/// This method uses *debug assertions* to check the validity of `length`
/// and may use other debug assertions.
#[inline]
pub unsafe fn set_len(&mut self, length: usize) {
debug_assert!(length <= self.capacity());
self.len = Index::from(length);
src/lib.rs
+14 -20
View File
@@ -134,7 +134,7 @@ impl<A: Array> ArrayVec<A> {
/// let array = ArrayVec::from([1, 2, 3]);
/// assert_eq!(array.capacity(), 3);
/// ```
#[inline]
#[inline(always)]
pub fn capacity(&self) -> usize { A::CAPACITY }
/// Return if the `ArrayVec` is completely filled.
@@ -235,14 +235,18 @@ impl<A: Array> ArrayVec<A> {
///
/// assert_eq!(&array[..], &[1, 2]);
/// ```
#[inline]
pub unsafe fn push_unchecked(&mut self, element: A::Item) {
let len = self.len();
debug_assert!(len < A::CAPACITY);
ptr::write(self.get_unchecked_mut(len), element);
ptr::write(self.get_unchecked_ptr(len), element);
self.set_len(len + 1);
}
/// Get pointer to where element at `index` would be
unsafe fn get_unchecked_ptr(&mut self, index: usize) -> *mut A::Item {
self.xs.ptr_mut().add(index)
}
/// Insert `element` at position `index`.
///
/// Shift up all elements after `index`.
@@ -300,7 +304,7 @@ impl<A: Array> ArrayVec<A> {
unsafe { // infallible
// The spot to put the new value
{
let p: *mut _ = self.get_unchecked_mut(index);
let p: *mut _ = self.get_unchecked_ptr(index);
// Shift everything over to make space. (Duplicating the
// `index`th element into two consecutive places.)
ptr::copy(p, p.offset(1), len - index);
@@ -334,7 +338,7 @@ impl<A: Array> ArrayVec<A> {
unsafe {
let new_len = self.len() - 1;
self.set_len(new_len);
Some(ptr::read(self.get_unchecked_mut(new_len)))
Some(ptr::read(self.get_unchecked_ptr(new_len)))
}
}
@@ -507,7 +511,6 @@ impl<A: Array> ArrayVec<A> {
///
/// This method uses *debug assertions* to check that `length` is
/// not greater than the capacity.
#[inline]
pub unsafe fn set_len(&mut self, length: usize) {
debug_assert!(length <= self.capacity());
self.len = Index::from(length);
@@ -628,7 +631,8 @@ impl<A: Array> ArrayVec<A> {
}
}
/// Dispose of `self` without the overwriting that is needed in Drop.
/// Dispose of `self` (same as drop)
#[deprecated="Use std::mem::drop instead, if at all needed."]
pub fn dispose(mut self) {
self.clear();
mem::forget(self);
@@ -754,7 +758,6 @@ pub struct IntoIter<A: Array> {
impl<A: Array> Iterator for IntoIter<A> {
type Item = A::Item;
#[inline]
fn next(&mut self) -> Option<A::Item> {
if self.index == self.v.len {
None
@@ -762,7 +765,7 @@ impl<A: Array> Iterator for IntoIter<A> {
unsafe {
let index = self.index.to_usize();
self.index = Index::from(index + 1);
Some(ptr::read(self.v.get_unchecked_mut(index)))
Some(ptr::read(self.v.get_unchecked_ptr(index)))
}
}
}
@@ -774,7 +777,6 @@ impl<A: Array> Iterator for IntoIter<A> {
}
impl<A: Array> DoubleEndedIterator for IntoIter<A> {
#[inline]
fn next_back(&mut self) -> Option<A::Item> {
if self.index == self.v.len {
None
@@ -782,7 +784,7 @@ impl<A: Array> DoubleEndedIterator for IntoIter<A> {
unsafe {
let new_len = self.v.len() - 1;
self.v.set_len(new_len);
Some(ptr::read(self.v.get_unchecked_mut(new_len)))
Some(ptr::read(self.v.get_unchecked_ptr(new_len)))
}
}
}
@@ -798,7 +800,7 @@ impl<A: Array> Drop for IntoIter<A> {
unsafe {
self.v.set_len(0);
let elements = slice::from_raw_parts_mut(
self.v.get_unchecked_mut(index),
self.v.get_unchecked_ptr(index),
len - index);
ptr::drop_in_place(elements);
}
@@ -851,7 +853,6 @@ impl<'a, A: Array> Iterator for Drain<'a, A>
{
type Item = A::Item;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|elt|
unsafe {
@@ -860,7 +861,6 @@ impl<'a, A: Array> Iterator for Drain<'a, A>
)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
@@ -869,7 +869,6 @@ impl<'a, A: Array> Iterator for Drain<'a, A>
impl<'a, A: Array> DoubleEndedIterator for Drain<'a, A>
where A::Item: 'a,
{
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|elt|
unsafe {
@@ -1068,27 +1067,22 @@ impl<A: Array> Default for ArrayVec<A> {
}
impl<A: Array> PartialOrd for ArrayVec<A> where A::Item: PartialOrd {
#[inline]
fn partial_cmp(&self, other: &ArrayVec<A>) -> Option<cmp::Ordering> {
(**self).partial_cmp(other)
}
#[inline]
fn lt(&self, other: &Self) -> bool {
(**self).lt(other)
}
#[inline]
fn le(&self, other: &Self) -> bool {
(**self).le(other)
}
#[inline]
fn ge(&self, other: &Self) -> bool {
(**self).ge(other)
}
#[inline]
fn gt(&self, other: &Self) -> bool {
(**self).gt(other)
}