use std::fmt;
use std::ops::{Deref, Range};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult};
use rustc_data_structures::sync::Lrc;
#[derive(Clone)]
pub struct RcVec<T> {
data: Lrc<Vec<T>>,
offset: u32,
len: u32,
}
impl<T> RcVec<T> {
pub fn new(mut vec: Vec<T>) -> Self {
vec.shrink_to_fit();
Self::new_preserving_capacity(vec)
}
pub fn new_preserving_capacity(vec: Vec<T>) -> Self {
RcVec {
offset: 0,
len: vec.len() as u32,
data: Lrc::new(vec),
}
}
pub fn sub_slice(&self, range: Range<usize>) -> Self {
RcVec {
data: self.data.clone(),
offset: self.offset + range.start as u32,
len: (range.end - range.start) as u32,
}
}
pub fn try_unwrap(self) -> Result<Vec<T>, Self> {
match Lrc::try_unwrap(self.data) {
Ok(mut vec) => {
vec.truncate(self.offset as usize + self.len as usize);
vec.drain(..self.offset as usize);
Ok(vec)
}
Err(data) => Err(RcVec { data, ..self }),
}
}
}
impl<T> Deref for RcVec<T> {
type Target = [T];
fn deref(&self) -> &[T] {
&self.data[self.offset as usize..(self.offset + self.len) as usize]
}
}
impl<T: fmt::Debug> fmt::Debug for RcVec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(self.deref(), f)
}
}
impl<CTX, T> HashStable<CTX> for RcVec<T>
where
T: HashStable<CTX>,
{
fn hash_stable<W: StableHasherResult>(&self, hcx: &mut CTX, hasher: &mut StableHasher<W>) {
(**self).hash_stable(hcx, hasher);
}
}