use core::fmt;
use core::hash::{self, Hash};
use core::iter::{repeat, FromIterator, IntoIterator};
-use core::marker::{self, ContravariantLifetime, InvariantType};
+use core::marker::PhantomData;
use core::mem;
-use core::nonzero::NonZero;
use core::num::{Int, UnsignedInt};
use core::ops::{Index, IndexMut, Deref, Add};
use core::ops;
use core::ptr;
+use core::ptr::Unique;
use core::raw::Slice as RawSlice;
use core::slice;
use core::usize;
#[unsafe_no_drop_flag]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Vec<T> {
- ptr: NonZero<*mut T>,
+ ptr: Unique<T>,
len: usize,
cap: usize,
- _own: marker::PhantomData<T>,
}
unsafe impl<T: Send> Send for Vec<T> { }
pub unsafe fn from_raw_parts(ptr: *mut T, length: usize,
capacity: usize) -> Vec<T> {
Vec {
- ptr: NonZero::new(ptr),
+ ptr: Unique::new(ptr),
len: length,
cap: capacity,
- _own: marker::PhantomData,
}
}
self.len * mem::size_of::<T>(),
mem::min_align_of::<T>()) as *mut T;
if ptr.is_null() { ::alloc::oom() }
- self.ptr = NonZero::new(ptr);
+ self.ptr = Unique::new(ptr);
}
self.cap = self.len;
}
unsafe {
let ptr = alloc_or_realloc(*self.ptr, old_size, size);
if ptr.is_null() { ::alloc::oom() }
- self.ptr = NonZero::new(ptr);
+ self.ptr = Unique::new(ptr);
}
self.cap = max(self.cap, 2) * 2;
}
Drain {
ptr: begin,
end: end,
- marker: ContravariantLifetime,
+ marker: PhantomData,
}
}
}
end_t: unsafe { start.offset(offset) },
start_u: start as *mut U,
end_u: start as *mut U,
+
+ _marker: PhantomData,
};
// start_t
// start_u
let mut pv = PartialVecZeroSized::<T,U> {
num_t: vec.len(),
num_u: 0,
- marker_t: InvariantType,
- marker_u: InvariantType,
+ marker: PhantomData,
};
unsafe { mem::forget(vec); }
unsafe {
let ptr = alloc_or_realloc(*self.ptr, self.cap * mem::size_of::<T>(), size);
if ptr.is_null() { ::alloc::oom() }
- self.ptr = NonZero::new(ptr);
+ self.ptr = Unique::new(ptr);
}
self.cap = capacity;
}
#[unsafe_no_drop_flag]
#[unstable(feature = "collections",
reason = "recently added as part of collections reform 2")]
-pub struct Drain<'a, T> {
+pub struct Drain<'a, T:'a> {
ptr: *const T,
end: *const T,
- marker: ContravariantLifetime<'a>,
+ marker: PhantomData<&'a T>,
}
#[stable(feature = "rust1", since = "1.0.0")]
/// Wrapper type providing a `&Vec<T>` reference via `Deref`.
#[unstable(feature = "collections")]
-pub struct DerefVec<'a, T> {
+pub struct DerefVec<'a, T:'a> {
x: Vec<T>,
- l: ContravariantLifetime<'a>
+ l: PhantomData<&'a T>,
}
#[unstable(feature = "collections")]
unsafe {
DerefVec {
x: Vec::from_raw_parts(x.as_ptr() as *mut T, x.len(), x.len()),
- l: ContravariantLifetime::<'a>
+ l: PhantomData,
}
}
}
end_u: *mut U,
start_t: *mut T,
end_t: *mut T,
+
+ _marker: PhantomData<U>,
}
/// An owned, partially type-converted vector of zero-sized elements.
struct PartialVecZeroSized<T,U> {
num_t: usize,
num_u: usize,
- marker_t: InvariantType<T>,
- marker_u: InvariantType<U>,
+ marker: PhantomData<::core::cell::Cell<(T,U)>>,
}
#[unsafe_destructor]