Struct rustc::ty::subst::VecPerParamSpace

pub struct VecPerParamSpace<T> {
    // some fields omitted
}

Unstable (rustc_private)

Vector of things sorted by param space. Used to keep the set of things declared on the type, self, or method distinct.

Methods

impl<T> VecPerParamSpace<T>

fn empty() -> VecPerParamSpace<T>

fn new(t: Vec<T>, s: Vec<T>, f: Vec<T>) -> VecPerParamSpace<T>

Unstable (rustc_private)

t is the type space. s is the self space. f is the fn space.

fn push(&mut self, space: ParamSpace, value: T)

Unstable (rustc_private)

Appends value to the vector associated with space.

Unlike the push method in Vec, this should not be assumed to be a cheap operation (even when amortized over many calls).

fn extend<I: Iterator<Item=T>>(&mut self, space: ParamSpace, values: I)

Unstable (rustc_private)

Appends values to the vector associated with space.

Unlike the extend method in Vec, this should not be assumed to be a cheap operation (even when amortized over many calls).

fn pop(&mut self, space: ParamSpace) -> Option<T>

fn truncate(&mut self, space: ParamSpace, len: usize)

fn replace(&mut self, space: ParamSpace, elems: Vec<T>)

fn get_self<'a>(&'a self) -> Option<&'a T>

fn len(&self, space: ParamSpace) -> usize

fn is_empty_in(&self, space: ParamSpace) -> bool

fn get_slice<'a>(&'a self, space: ParamSpace) -> &'a [T]

fn get_mut_slice<'a>(&'a mut self, space: ParamSpace) -> &'a mut [T]

fn opt_get<'a>(&'a self, space: ParamSpace, index: usize) -> Option<&'a T>

fn get<'a>(&'a self, space: ParamSpace, index: usize) -> &'a T

fn iter<'a>(&'a self) -> Iter<'a, T>

fn into_iter(self) -> IntoIter<T>

fn iter_enumerated<'a>(&'a self) -> EnumeratedItems<'a, T>

fn as_slice(&self) -> &[T]

fn into_vec(self) -> Vec<T>

fn all_vecs<P>(&self, pred: P) -> bool where P: FnMut(&[T]) -> bool

fn all<P>(&self, pred: P) -> bool where P: FnMut(&T) -> bool

fn any<P>(&self, pred: P) -> bool where P: FnMut(&T) -> bool

fn is_empty(&self) -> bool

fn map<U, P>(&self, pred: P) -> VecPerParamSpace<U> where P: FnMut(&T) -> U

fn map_enumerated<U, P>(&self, pred: P) -> VecPerParamSpace<U> where P: FnMut((ParamSpace, usize, &T)) -> U

fn split(self) -> SeparateVecsPerParamSpace<T>

fn with_slice(self, space: ParamSpace, slice: &[T]) -> VecPerParamSpace<T> where T: Clone

Trait Implementations

impl<T: Debug> Debug for VecPerParamSpace<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> IntoIterator for VecPerParamSpace<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a VecPerParamSpace<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for VecPerParamSpace<T>

fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self

fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool

fn fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self

fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool

fn has_regions_escaping_depth(&self, depth: u32) -> bool

fn has_escaping_regions(&self) -> bool

fn has_type_flags(&self, flags: TypeFlags) -> bool

fn has_projection_types(&self) -> bool

fn references_error(&self) -> bool

fn has_param_types(&self) -> bool

fn has_self_ty(&self) -> bool

fn has_infer_types(&self) -> bool

fn needs_infer(&self) -> bool

fn needs_subst(&self) -> bool

fn has_closure_types(&self) -> bool

fn has_erasable_regions(&self) -> bool

fn is_global(&self) -> bool

Indicates whether this value references only 'global' types/lifetimes that are the same regardless of what fn we are in. This is used for caching. Errs on the side of returning false.

Derived Implementations

impl<T: Decodable> Decodable for VecPerParamSpace<T>

fn decode<__DT: Decoder>(__arg_0: &mut __DT) -> Result<VecPerParamSpace<T>, __DT::Error>

impl<T: Encodable> Encodable for VecPerParamSpace<T>

fn encode<__ST: Encoder>(&self, __arg_0: &mut __ST) -> Result<(), __ST::Error>

impl<T: Hash> Hash for VecPerParamSpace<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<T: Clone> Clone for VecPerParamSpace<T>

fn clone(&self) -> VecPerParamSpace<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Eq> Eq for VecPerParamSpace<T>

impl<T: PartialEq> PartialEq for VecPerParamSpace<T>

fn eq(&self, __arg_0: &VecPerParamSpace<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &VecPerParamSpace<T>) -> bool

This method tests for !=.