amethyst
/
veccell
mirror of https://github.com/adri326/veccell
1
0
Fork 0
Code Issues Releases Wiki Activity

Add Default implementation

Browse Source
main
Markus Mayer 1 year ago committed by Shad Amethyst
parent ab2aa8103b
commit 6e2e8bb085
2 changed files with 75 additions and 29 deletions
Show Stats Download Patch File Download Diff File

81
src/lib.rs
Unescape View File

@ -102,7 +102,7 @@ impl<T> VecCell<T> {
Self {
mut_borrow: Cell::new(None),
borrows: Cell::new(0),
inner: Vec::with_capacity(capacity)
inner: Vec::with_capacity(capacity),
}
}
@ -356,7 +356,10 @@ impl<T> VecCell<T> {
/// assert_eq!(s[1], 2);
/// assert!(s.get(2).is_none());
/// ```
pub fn borrow_range<'b, R: std::ops::RangeBounds<usize>>(&'b self, range: R) -> Option<VecRef<'b, [T]>> {
pub fn borrow_range<'b, R: std::ops::RangeBounds<usize>>(
&'b self,
range: R,
) -> Option<VecRef<'b, [T]>> {
VecRef::from_range(self, range)
}
@ -491,9 +494,7 @@ impl<T> VecCell<T> {
/// std::mem::drop(x);
/// ```
pub fn try_iter<'b>(&'b self) -> impl Iterator<Item = Option<VecRef<'b, T>>> {
(0..self.len()).map(|index| {
self.borrow(index)
})
(0..self.len()).map(|index| self.borrow(index))
}
/// Resets the [`borrows`](VecCell::borrows) and [`mut_borrow`](VecCell::mut_borrow) counters.
@ -547,7 +548,11 @@ impl<T> VecCell<T> {
/// If no reference was [forgotten](std::mem::forget), then `mut_borrow == None` and `borrows == 0`.
#[inline]
pub fn into_raw_parts(self) -> (Vec<UnsafeCell<T>>, Option<usize>, usize) {
(self.inner, self.mut_borrow.into_inner(), self.borrows.into_inner())
(
self.inner,
self.mut_borrow.into_inner(),
self.borrows.into_inner(),
)
}
// == Unsafe functions section ==
@ -571,7 +576,11 @@ impl<T> VecCell<T> {
}
/// Constructs a `VecCell` from its raw parts.
pub unsafe fn from_raw_parts(inner: Vec<UnsafeCell<T>>, mut_borrow: Option<usize>, borrows: usize) -> Self {
pub unsafe fn from_raw_parts(
inner: Vec<UnsafeCell<T>>,
mut_borrow: Option<usize>,
borrows: usize,
) -> Self {
Self {
inner,
borrows: Cell::new(borrows),
@ -599,12 +608,16 @@ impl<T: fmt::Debug> fmt::Debug for VecCell<T> {
f.debug_struct("VecCell")
.field("borrows", &self.borrows.get())
.field("mut_borrow", &self.mut_borrow.get())
.field("inner", &self.try_iter().map(|x| {
match x {
.field(
"inner",
&self
.try_iter()
.map(|x| match x {
Some(y) => BorrowStatus::Ok(y),
None => BorrowStatus::Borrowed,
}
}).collect::<Box<[_]>>())
})
.collect::<Box<[_]>>(),
)
.finish()
}
}
@ -619,7 +632,7 @@ impl<'a, T: 'a> IntoIterator for &'a VecCell<T> {
fn into_iter(self) -> Self::IntoIter {
VecCellRefIter {
vec: self,
index: 0
index: 0,
}
}
}
@ -629,7 +642,7 @@ impl<'a, T: 'a> IntoIterator for &'a VecCell<T> {
#[derive(Clone)]
pub struct VecCellRefIter<'a, T> {
vec: &'a VecCell<T>,
index: usize
index: usize,
}
impl<'a, T> Iterator for VecCellRefIter<'a, T> {
@ -637,12 +650,15 @@ impl<'a, T> Iterator for VecCellRefIter<'a, T> {
fn next(&mut self) -> Option<Self::Item> {
if self.index >= self.vec.len() {
return None
return None;
}
let res = match self.vec.borrow(self.index) {
Some(x) => x,
None => panic!("Error while borrowing immutably element {} of VecCell: already mutably borrowed", self.index),
None => panic!(
"Error while borrowing immutably element {} of VecCell: already mutably borrowed",
self.index
),
};
self.index += 1;
@ -681,7 +697,7 @@ impl<T> IntoIterator for VecCell<T> {
/// Panics if a value is currently mutably borrowed
fn into_iter(self) -> Self::IntoIter {
VecCellIntoIter {
iter: self.inner.into_iter()
iter: self.inner.into_iter(),
}
}
}
@ -718,7 +734,10 @@ impl<T: Clone> Clone for VecCell<T> {
/// Panics if a value is currently mutably borrowed
fn clone(&self) -> Self {
VecCell {
inner: self.into_iter().map(|x| UnsafeCell::new((*x).clone())).collect::<Vec<_>>(),
inner: self
.into_iter()
.map(|x| UnsafeCell::new((*x).clone()))
.collect::<Vec<_>>(),
mut_borrow: Cell::new(None),
borrows: Cell::new(0),
}
@ -731,12 +750,12 @@ impl<T: PartialEq> PartialEq for VecCell<T> {
/// Panics if a value in `self` or `other` is currently mutably borrowed when it is encountered in the comparison.
fn eq(&self, other: &Self) -> bool {
if self.len() != other.len() {
return false
return false;
}
for (s, o) in self.iter().zip(other.iter()) {
if *s != *o {
return false
return false;
}
}
@ -750,12 +769,12 @@ impl<T: PartialEq> PartialEq<Vec<T>> for VecCell<T> {
/// Panics if a value in `self` is currently mutably borrowed when it is encountered in the comparison.
fn eq(&self, other: &Vec<T>) -> bool {
if self.len() != other.len() {
return false
return false;
}
for (s, o) in self.iter().zip(other.iter()) {
if *s != *o {
return false
return false;
}
}
@ -766,7 +785,10 @@ impl<T: PartialEq> PartialEq<Vec<T>> for VecCell<T> {
impl<T> From<Vec<T>> for VecCell<T> {
fn from(vec: Vec<T>) -> Self {
VecCell {
inner: vec.into_iter().map(|x| UnsafeCell::new(x)).collect::<Vec<_>>(),
inner: vec
.into_iter()
.map(|x| UnsafeCell::new(x))
.collect::<Vec<_>>(),
mut_borrow: Cell::new(None),
borrows: Cell::new(0),
}
@ -783,9 +805,11 @@ impl<T> From<VecCell<T>> for Vec<T> {
impl<T: serde::Serialize> serde::Serialize for VecCell<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer
S: serde::Serializer,
{
let range = self.borrow_range(..).expect("Cannot borrow immutably VecCell: already borrowed mutably.");
let range = self
.borrow_range(..)
.expect("Cannot borrow immutably VecCell: already borrowed mutably.");
(*range).serialize(serializer)
}
}
@ -794,13 +818,20 @@ impl<T: serde::Serialize> serde::Serialize for VecCell<T> {
impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for VecCell<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>
D: serde::Deserializer<'de>,
{
let vec: Vec<T> = Vec::deserialize(deserializer)?;
Ok(Self::from(vec))
}
}
impl<T> Default for VecCell<T> {
#[inline(always)]
fn default() -> Self {
VecCell::new()
}
}
#[cfg(test)]
mod test;

19
src/test.rs
Unescape View File

@ -19,7 +19,6 @@ fn test_create_vec() {
assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), usize::MAX);
let vec: VecCell<usize> = VecCell::with_capacity(0);
assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 0);
@ -31,6 +30,21 @@ fn test_create_vec() {
assert_eq!(vec.capacity(), usize::MAX);
}
#[test]
fn test_default_vec() {
let container: Container<usize> = Container::default();
assert_eq!(container.vec.len(), 0);
let container: Container<i8> = Container::default();
assert_eq!(container.vec.len(), 0);
let container: Container<()> = Container::default();
assert_eq!(container.vec.len(), 0);
#[derive(Default)]
struct Container<T> {
vec: VecCell<T>,
}
}
#[test]
fn test_push() {
let mut vec: VecCell<usize> = VecCell::with_capacity(1);
@ -284,7 +298,8 @@ fn test_try_map() {
assert!(VecRefMut::try_map(ref_mut, |_value| Err::<&mut (), ()>(())).is_err());
let ref_mut = vec.borrow_mut(5).unwrap();
let ref_mut: Result<VecRefMut<'_, i32>, ()> = VecRefMut::try_map(ref_mut, |value| Ok(value.as_mut()));
let ref_mut: Result<VecRefMut<'_, i32>, ()> =
VecRefMut::try_map(ref_mut, |value| Ok(value.as_mut()));
assert!(ref_mut.is_ok());
assert_eq!(ref_mut.unwrap(), -5);

Write Preview
Loading…
Cancel
Save