Struct rustc_typeck::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>(&mut self, space: ParamSpace, values: I) where I: Iterator<Item=T>

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 self) -> Option<&'a T>

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

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

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

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

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

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

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

fn into_iter(self) -> IntoIter<T>

fn iter_enumerated(&'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 for VecPerParamSpace<T> where T: Debug

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

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 for VecPerParamSpace<T> where T: RegionEscape

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

fn has_escaping_regions(&self) -> bool

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

fn has_projection_types(&self) -> bool

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

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

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

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

Derived Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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