Struct rustc::middle::subst::VecPerParamSpaceUnstable [-] [+] [src]

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

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 params_from_type(types: Vec<T>) -> VecPerParamSpace<T>

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

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

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

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)

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 map_move<U, F>(self, pred: F) -> VecPerParamSpace<U> where F: FnMut(T) -> U

fn split(self) -> SeparateVecsPerParamSpace<T>

fn with_vec(self, space: ParamSpace, vec: Vec<T>) -> VecPerParamSpace<T>

Trait Implementations

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

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

impl<T> IntoIterator for VecPerParamSpace<T>

type Item = T

type IntoIter = IntoIter<T>

fn into_iter(self) -> IntoIter<T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

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

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

fn has_escaping_regions(&self) -> bool

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

fn has_projection_types(&self) -> bool

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

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

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

fn repr(&self, tcx: &ctxt<'tcx>) -> String

Derived Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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