Struct rustc_index::interval::SparseIntervalMatrix

source ·

pub struct SparseIntervalMatrix<R, C>where
    R: Idx,
    C: Idx,{
    rows: IndexVec<R, IntervalSet<C>>,
    column_size: usize,
}

Expand description

This data structure optimizes for cases where the stored bits in each row are expected to be highly contiguous (long ranges of 1s or 0s), in contrast to BitMatrix and SparseBitMatrix which are optimized for “random”/non-contiguous bits and cheap(er) point queries at the expense of memory usage.

Fields§

§rows: IndexVec<R, IntervalSet<C>>§column_size: usize

Struct rustc_index::interval::SparseIntervalMatrixCopy item path

Fields§

Implementations§

impl<R: Idx, C: Step + Idx> SparseIntervalMatrix<R, C>

pub fn new(column_size: usize) -> SparseIntervalMatrix<R, C>

pub fn rows(&self) -> impl Iterator<Item = R>

pub fn row(&self, row: R) -> Option<&IntervalSet<C>>

fn ensure_row(&mut self, row: R) -> &mut IntervalSet<C>

pub fn union_row(&mut self, row: R, from: &IntervalSet<C>) -> boolwhere C: Step,

pub fn union_rows(&mut self, read: R, write: R) -> boolwhere C: Step,

pub fn insert_all_into_row(&mut self, row: R)

pub fn insert_range(&mut self, row: R, range: impl RangeBounds<C> + Clone)

pub fn insert(&mut self, row: R, point: C) -> bool

pub fn contains(&self, row: R, point: C) -> bool

Trait Implementations§

impl<R, C> Clone for SparseIntervalMatrix<R, C>where R: Idx + Clone, C: Idx + Clone,

fn clone(&self) -> SparseIntervalMatrix<R, C>

fn clone_from(&mut self, source: &Self)

Auto Trait Implementations§

impl<R, C> Freeze for SparseIntervalMatrix<R, C>

impl<R, C> RefUnwindSafe for SparseIntervalMatrix<R, C>where C: RefUnwindSafe,

impl<R, C> Send for SparseIntervalMatrix<R, C>where C: Send,

impl<R, C> Sync for SparseIntervalMatrix<R, C>where C: Sync,

impl<R, C> Unpin for SparseIntervalMatrix<R, C>where C: Unpin,

impl<R, C> UnwindSafe for SparseIntervalMatrix<R, C>where C: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Layout§

Struct rustc_index::interval::SparseIntervalMatrix

pub fn union_row(&mut self, row: R, from: &IntervalSet<C>) -> bool
where C: Step,

pub fn union_rows(&mut self, read: R, write: R) -> bool
where C: Step,

impl<R, C> Clone for SparseIntervalMatrix<R, C>
where R: Idx + Clone, C: Idx + Clone,

impl<R, C> RefUnwindSafe for SparseIntervalMatrix<R, C>
where C: RefUnwindSafe,

impl<R, C> Send for SparseIntervalMatrix<R, C>
where C: Send,

impl<R, C> Sync for SparseIntervalMatrix<R, C>
where C: Sync,

impl<R, C> Unpin for SparseIntervalMatrix<R, C>
where C: Unpin,

impl<R, C> UnwindSafe for SparseIntervalMatrix<R, C>
where C: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,