#![cfg_attr(rustdoc, feature(rustdoc))]
#[cfg(rustdoc)]
-extern crate "rustdoc" as this;
+extern crate rustdoc as this;
#[cfg(rustc)]
-extern crate "rustc_driver" as this;
+extern crate rustc_driver as this;
fn main() { this::main() }
impl Index<usize> for BitVec {
type Output = bool;
-
- #[cfg(stage0)]
- #[inline]
- fn index(&self, i: &usize) -> &bool {
- if self.get(*i).expect("index out of bounds") {
- &TRUE
- } else {
- &FALSE
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &bool {
if self.get(i).expect("index out of bounds") {
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
- where K: Borrow<Q>, Q: Ord
-{
- type Output = V;
-
- #[inline]
- fn index(&self, key: &Q) -> &V {
- self.get(key).expect("no entry found for key")
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
where K: Borrow<Q>, Q: Ord
}
/// Returns a sub-slice with elements starting with `min_key`.
- #[cfg(stage0)]
- pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
- // _______________
- // |_1_|_3_|_5_|_7_|
- // | | | | |
- // 0 0 1 1 2 2 3 3 4 index
- // | | | | |
- // \___|___|___|___/ slice_from(&0); pos = 0
- // \___|___|___/ slice_from(&2); pos = 1
- // |___|___|___/ slice_from(&3); pos = 1; result.head_is_edge = false
- // \___|___/ slice_from(&4); pos = 2
- // \___/ slice_from(&6); pos = 3
- // \|/ slice_from(&999); pos = 4
- let (pos, pos_is_kv) = self.search_linear(min_key);
- $NodeSlice {
- has_edges: self.has_edges,
- edges: if !self.has_edges {
- self.edges
- } else {
- self.edges.$index(&(pos ..))
- },
- keys: &self.keys[pos ..],
- vals: self.vals.$index(&(pos ..)),
- head_is_edge: !pos_is_kv,
- tail_is_edge: self.tail_is_edge,
- }
- }
-
- /// Returns a sub-slice with elements starting with `min_key`.
- #[cfg(not(stage0))]
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
}
/// Returns a sub-slice with elements up to and including `max_key`.
- #[cfg(stage0)]
- pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
- // _______________
- // |_1_|_3_|_5_|_7_|
- // | | | | |
- // 0 0 1 1 2 2 3 3 4 index
- // | | | | |
- //\|/ | | | | slice_to(&0); pos = 0
- // \___/ | | | slice_to(&2); pos = 1
- // \___|___| | | slice_to(&3); pos = 1; result.tail_is_edge = false
- // \___|___/ | | slice_to(&4); pos = 2
- // \___|___|___/ | slice_to(&6); pos = 3
- // \___|___|___|___/ slice_to(&999); pos = 4
- let (pos, pos_is_kv) = self.search_linear(max_key);
- let pos = pos + if pos_is_kv { 1 } else { 0 };
- $NodeSlice {
- has_edges: self.has_edges,
- edges: if !self.has_edges {
- self.edges
- } else {
- self.edges.$index(&(.. (pos + 1)))
- },
- keys: &self.keys[..pos],
- vals: self.vals.$index(&(.. pos)),
- head_is_edge: self.head_is_edge,
- tail_is_edge: !pos_is_kv,
- }
- }
-
- /// Returns a sub-slice with elements up to and including `max_key`.
- #[cfg(not(stage0))]
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
impl ops::Index<ops::Range<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeTo<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeFrom<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeFull> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &str {
- unsafe { mem::transmute(&*self.vec) }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
unsafe { mem::transmute(&*self.vec) }
impl<T> Index<usize> for Vec<T> {
type Output = T;
-
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &usize) -> &T {
- // NB built-in indexing via `&[T]`
- &(**self)[*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: usize) -> &T {
// NB built-in indexing via `&[T]`
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> IndexMut<usize> for Vec<T> {
-
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &usize) -> &mut T {
- // NB built-in indexing via `&mut [T]`
- &mut (**self)[*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeFull> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &[T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &[T] {
self
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
- self.as_mut_slice()
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: ops::RangeFull) -> &mut [T] {
self.as_mut_slice()
impl<A> Index<usize> for VecDeque<A> {
type Output = A;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, i: &usize) -> &A {
- self.get(*i).expect("Out of bounds access")
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &A {
self.get(i).expect("Out of bounds access")
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> IndexMut<usize> for VecDeque<A> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, i: &usize) -> &mut A {
- self.get_mut(*i).expect("Out of bounds access")
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, i: usize) -> &mut A {
self.get_mut(i).expect("Out of bounds access")
}
}
-#[cfg(stage0)]
-impl<V> Index<usize> for VecMap<V> {
- type Output = V;
-
- #[inline]
- fn index<'a>(&'a self, i: &usize) -> &'a V {
- self.get(i).expect("key not present")
- }
-}
-
-#[cfg(not(stage0))]
impl<V> Index<usize> for VecMap<V> {
type Output = V;
}
}
-#[cfg(not(stage0))]
impl<'a,V> Index<&'a usize> for VecMap<V> {
type Output = V;
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> IndexMut<usize> for VecMap<V> {
- #[inline]
- fn index_mut(&mut self, i: &usize) -> &mut V {
- self.get_mut(&i).expect("key not present")
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> IndexMut<usize> for VecMap<V> {
#[inline]
}
}
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> IndexMut<&'a usize> for VecMap<V> {
#[inline]
use marker::Sized;
-#[cfg(stage0)] pub use self::copy_memory as copy;
-#[cfg(stage0)] pub use self::set_memory as write_bytes;
-#[cfg(stage0)] pub use self::copy_nonoverlapping_memory as copy_nonoverlapping;
-
extern "rust-intrinsic" {
// NB: These intrinsics take unsafe pointers because they mutate aliased
pub fn pref_align_of<T>() -> usize;
/// Gets a static string slice containing the name of a type.
- #[cfg(not(stage0))]
pub fn type_name<T: ?Sized>() -> &'static str;
/// Gets an identifier which is globally unique to the specified type. This
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- #[cfg(not(stage0))]
pub fn copy_nonoverlapping<T>(dst: *mut T, src: *const T, count: usize);
- /// dox
- #[stable(feature = "rust1", since = "1.0.0")]
- #[cfg(stage0)]
- pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: usize);
-
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
/// and destination may overlap.
///
/// }
/// ```
///
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn copy<T>(dst: *mut T, src: *const T, count: usize);
- /// dox
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn copy_memory<T>(dst: *mut T, src: *const T, count: usize);
-
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
- /// dox
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn set_memory<T>(dst: *mut T, val: u8, count: usize);
-
/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
/// a size of `count` * `size_of::<T>()` and an alignment of
/// `min_align_of::<T>()`
type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- fn index<'a>(&'a self, index: &Idx) -> &'a Self::Output;
-
- /// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index<'a>(&'a self, index: Idx) -> &'a Self::Output;
}
#[stable(feature = "rust1", since = "1.0.0")]
pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
/// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- fn index_mut<'a>(&'a mut self, index: &Idx) -> &'a mut Self::Output;
-
- /// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index_mut<'a>(&'a mut self, index: Idx) -> &'a mut Self::Output;
}
#[lang="fn"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
-#[cfg(stage0)]
-pub trait Fn<Args> {
- /// The returned type after the call operator is used.
- type Output;
-
- /// This is called when the call operator is used.
- extern "rust-call" fn call(&self, args: Args) -> Self::Output;
-}
-
-/// A version of the call operator that takes an immutable receiver.
-#[lang="fn"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_paren_sugar]
-#[cfg(not(stage0))]
pub trait Fn<Args> : FnMut<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
#[lang="fn_mut"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
-#[cfg(stage0)]
-pub trait FnMut<Args> {
- /// The returned type after the call operator is used.
- type Output;
-
- /// This is called when the call operator is used.
- extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
-}
-
-/// A version of the call operator that takes a mutable receiver.
-#[lang="fn_mut"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_paren_sugar]
-#[cfg(not(stage0))]
pub trait FnMut<Args> : FnOnce<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
/// This is called when the call operator is used.
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}
-
-#[cfg(stage0)]
-impl<F: ?Sized, A> FnMut<A> for F
- where F : Fn<A>
-{
- type Output = <F as Fn<A>>::Output;
-
- extern "rust-call" fn call_mut(&mut self, args: A) -> <F as Fn<A>>::Output {
- self.call(args)
- }
-}
-
-#[cfg(stage0)]
-impl<F,A> FnOnce<A> for F
- where F : FnMut<A>
-{
- type Output = <F as FnMut<A>>::Output;
-
- extern "rust-call" fn call_once(mut self, args: A) -> <F as FnMut<A>>::Output {
- self.call_mut(args)
- }
-}
#[inline]
fn as_mut_slice(&mut self) -> &mut [T] { self }
- #[cfg(stage0)]
- #[inline]
- fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
- unsafe {
- let self2: &mut [T] = mem::transmute_copy(&self);
-
- (ops::IndexMut::index_mut(self, &ops::RangeTo { end: mid } ),
- ops::IndexMut::index_mut(self2, &ops::RangeFrom { start: mid } ))
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
unsafe {
impl<T> ops::Index<usize> for [T] {
type Output = T;
- #[cfg(stage0)]
- fn index(&self, &index: &usize) -> &T {
- assert!(index < self.len());
-
- unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
- }
-
- #[cfg(not(stage0))]
fn index(&self, index: usize) -> &T {
assert!(index < self.len());
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<usize> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, &index: &usize) -> &mut T {
- assert!(index < self.len());
-
- unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
assert!(index < self.len());
impl<T> ops::Index<ops::Range<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- assert!(index.start <= index.end);
- assert!(index.end <= self.len());
- unsafe {
- from_raw_parts (
- self.as_ptr().offset(index.start as isize),
- index.end - index.start
- )
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
assert!(index.start <= index.end);
impl<T> ops::Index<ops::RangeTo<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.index(&ops::Range{ start: 0, end: index.end })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(ops::Range{ start: 0, end: index.end })
impl<T> ops::Index<ops::RangeFrom<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.index(&ops::Range{ start: index.start, end: self.len() })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(ops::Range{ start: index.start, end: self.len() })
impl<T> ops::Index<RangeFull> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- assert!(index.start <= index.end);
- assert!(index.end <= self.len());
- unsafe {
- from_raw_parts_mut(
- self.as_mut_ptr().offset(index.start as isize),
- index.end - index.start
- )
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
assert!(index.start <= index.end);
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- self.index_mut(&ops::Range{ start: 0, end: index.end })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(ops::Range{ start: 0, end: index.end })
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- let len = self.len();
- self.index_mut(&ops::Range{ start: index.start, end: len })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
let len = self.len();
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<RangeFull> for [T] {
-
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
self
impl<'a, T> ops::Index<ops::Range<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<ops::RangeTo<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- self.as_slice()
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self.as_slice()
impl<'a, T> ops::Index<ops::Range<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<ops::RangeTo<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- make_slice!(T => &[T]: self.ptr, self.end)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
make_slice!(T => &[T]: self.ptr, self.end)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
- make_mut_slice!(T => &mut [T]: self.ptr, self.end)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
make_mut_slice!(T => &mut [T]: self.ptr, self.end)
#[derive(Copy, Clone)]
struct BytesDeref;
-#[cfg(stage0)]
-impl<'a> Fn<(&'a u8,)> for BytesDeref {
- type Output = u8;
-
- #[inline]
- extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
- *ptr
- }
-}
-
-#[cfg(not(stage0))]
impl<'a> Fn<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnMut<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call_mut(&mut self, (ptr,): (&'a u8,)) -> u8 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnOnce<(&'a u8,)> for BytesDeref {
type Output = u8;
/// // byte 100 is outside the string
/// // &s[3 .. 100];
/// ```
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- impl ops::Index<ops::Range<usize>> for str {
- type Output = str;
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if index.start <= index.end &&
- self.is_char_boundary(index.start) &&
- self.is_char_boundary(index.end) {
- unsafe { self.slice_unchecked(index.start, index.end) }
- } else {
- super::slice_error_fail(self, index.start, index.end)
- }
- }
- }
-
- /// Returns a slice of the given string from the byte range
- /// [`begin`..`end`).
- ///
- /// This operation is `O(1)`.
- ///
- /// Panics when `begin` and `end` do not point to valid characters
- /// or point beyond the last character of the string.
- ///
- /// # Examples
- ///
- /// ```
- /// let s = "Löwe 老虎 Léopard";
- /// assert_eq!(&s[0 .. 1], "L");
- ///
- /// assert_eq!(&s[1 .. 9], "öwe 老");
- ///
- /// // these will panic:
- /// // byte 2 lies within `ö`:
- /// // &s[2 ..3];
- ///
- /// // byte 8 lies within `老`
- /// // &s[1 .. 8];
- ///
- /// // byte 100 is outside the string
- /// // &s[3 .. 100];
- /// ```
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::Range<usize>> for str {
type Output = str;
impl ops::Index<ops::RangeTo<usize>> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.end) {
- unsafe { self.slice_unchecked(0, index.end) }
- } else {
- super::slice_error_fail(self, 0, index.end)
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
impl ops::Index<ops::RangeFrom<usize>> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.start) {
- unsafe { self.slice_unchecked(index.start, self.len()) }
- } else {
- super::slice_error_fail(self, index.start, self.len())
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
impl ops::Index<ops::RangeFull> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &str {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
self
#![allow(bad_style, raw_pointer_derive)]
#![cfg_attr(target_os = "nacl", allow(unused_imports))]
-#[cfg(feature = "cargo-build")] extern crate "std" as core;
+#[cfg(feature = "cargo-build")] extern crate std as core;
#[cfg(not(feature = "cargo-build"))] extern crate core;
#[cfg(test)] extern crate std;
#[macro_use] extern crate syntax;
#[macro_use] #[no_link] extern crate rustc_bitflags;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
#[cfg(test)]
extern crate test;
// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
// refers to the borrowck-specific graphviz adapter traits.
-extern crate "graphviz" as dot;
+extern crate graphviz as dot;
extern crate rustc;
pub use borrowck::check_crate;
extern crate rustc_trans;
extern crate rustc_typeck;
extern crate serialize;
-extern crate "rustc_llvm" as llvm;
+extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
extern crate rustc;
extern crate rustc_back;
extern crate serialize;
-extern crate "rustc_llvm" as llvm;
+extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
extern crate rustc_back;
extern crate serialize;
extern crate syntax;
-extern crate "test" as testing;
+extern crate test as testing;
extern crate unicode;
#[macro_use] extern crate log;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
use std::cell::RefCell;
use std::collections::HashMap;
}
}
-#[cfg(stage0)]
-impl<'a> Index<&'a str> for Json {
- type Output = Json;
-
- fn index(&self, idx: & &str) -> &Json {
- self.find(*idx).unwrap()
- }
-}
-
-#[cfg(not(stage0))]
impl<'a> Index<&'a str> for Json {
type Output = Json;
}
}
-#[cfg(stage0)]
-impl Index<uint> for Json {
- type Output = Json;
-
- fn index<'a>(&'a self, idx: &uint) -> &'a Json {
- match self {
- &Json::Array(ref v) => &v[*idx],
- _ => panic!("can only index Json with uint if it is an array")
- }
- }
-}
-
-#[cfg(not(stage0))]
impl Index<uint> for Json {
type Output = Json;
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, Q: ?Sized, V, S> Index<Q> for HashMap<K, V, S>
- where K: Eq + Hash + Borrow<Q>,
- Q: Eq + Hash,
- S: HashState,
-{
- type Output = V;
-
- #[inline]
- fn index<'a>(&'a self, index: &Q) -> &'a V {
- self.get(index).expect("no entry found for key")
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap<K, V, S>
where K: Eq + Hash + Borrow<Q>,
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFull> for OsString {
- type Output = OsStr;
-
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &OsStr {
- unsafe { mem::transmute(self.inner.as_slice()) }
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::RangeFull> for OsString {
type Output = OsStr;
#[macro_use]
#[macro_reexport(vec, format)]
-extern crate "collections" as core_collections;
+extern crate collections as core_collections;
-#[allow(deprecated)] extern crate "rand" as core_rand;
+#[allow(deprecated)] extern crate rand as core_rand;
extern crate alloc;
extern crate unicode;
extern crate libc;
#[macro_use] #[no_link] extern crate rustc_bitflags;
// Make std testable by not duplicating lang items. See #2912
-#[cfg(test)] extern crate "std" as realstd;
+#[cfg(test)] extern crate std as realstd;
#[cfg(test)] pub use realstd::marker;
#[cfg(test)] pub use realstd::ops;
#[cfg(test)] pub use realstd::cmp;
#[cfg(test)]
mod test {
- extern crate "test" as test_crate;
+ extern crate test as test_crate;
use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer};
use prelude::v1::{Ok, Err, Vec, AsSlice};
use prelude::v1::IteratorExt;
///
/// Panics when `begin` and `end` do not point to code point boundaries,
/// or point beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::Range<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::Range<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if range.start <= range.end &&
- is_code_point_boundary(self, range.start) &&
- is_code_point_boundary(self, range.end) {
- unsafe { slice_unchecked(self, range.start, range.end) }
- } else {
- slice_error_fail(self, range.start, range.end)
- }
- }
-}
-
-/// Return a slice of the given string for the byte range [`begin`..`end`).
-///
-/// # Panics
-///
-/// Panics when `begin` and `end` do not point to code point boundaries,
-/// or point beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::Range<usize>> for Wtf8 {
type Output = Wtf8;
///
/// Panics when `begin` is not at a code point boundary,
/// or is beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::RangeFrom<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if is_code_point_boundary(self, range.start) {
- unsafe { slice_unchecked(self, range.start, self.len()) }
- } else {
- slice_error_fail(self, range.start, self.len())
- }
- }
-}
-
-/// Return a slice of the given string from byte `begin` to its end.
-///
-/// # Panics
-///
-/// Panics when `begin` is not at a code point boundary,
-/// or is beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
type Output = Wtf8;
///
/// Panics when `end` is not at a code point boundary,
/// or is beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::RangeTo<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if is_code_point_boundary(self, range.end) {
- unsafe { slice_unchecked(self, 0, range.end) }
- } else {
- slice_error_fail(self, 0, range.end)
- }
- }
-}
-
-/// Return a slice of the given string from its beginning to byte `end`.
-///
-/// # Panics
-///
-/// Panics when `end` is not at a code point boundary,
-/// or is beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
type Output = Wtf8;
}
}
-#[cfg(stage0)]
-impl ops::Index<ops::RangeFull> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, _range: &ops::RangeFull) -> &Wtf8 {
- self
- }
-}
-
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeFull> for Wtf8 {
type Output = Wtf8;
#[macro_use] extern crate log;
#[macro_use] #[no_link] extern crate rustc_bitflags;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
pub mod util {
pub mod interner;
extern crate getopts;
extern crate serialize;
-extern crate "serialize" as rustc_serialize;
+extern crate serialize as rustc_serialize;
extern crate term;
extern crate libc;
pub use tables::normalization::canonical_combining_class;
pub use tables::UNICODE_VERSION;
-#[cfg(stage0)]
-/// Functionality for manipulating `char`.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait CharExt {
- /// Checks if a `char` parses as a numeric digit in the given radix.
- ///
- /// Compared to `is_numeric()`, this function only recognizes the characters
- /// `0-9`, `a-z` and `A-Z`.
- ///
- /// # Return value
- ///
- /// Returns `true` if `c` is a valid digit under `radix`, and `false`
- /// otherwise.
- ///
- /// # Panics
- ///
- /// Panics if given a radix > 36.
- ///
- /// # Examples
- ///
- /// ```
- /// let c = '1';
- ///
- /// assert!(c.is_digit(10));
- ///
- /// assert!('f'.is_digit(16));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_digit(self, radix: u32) -> bool;
-
- /// Converts a character to the corresponding digit.
- ///
- /// # Return value
- ///
- /// If `c` is between '0' and '9', the corresponding value between 0 and
- /// 9. If `c` is 'a' or 'A', 10. If `c` is 'b' or 'B', 11, etc. Returns
- /// none if the character does not refer to a digit in the given radix.
- ///
- /// # Panics
- ///
- /// Panics if given a radix outside the range [0..36].
- ///
- /// # Examples
- ///
- /// ```
- /// let c = '1';
- ///
- /// assert_eq!(c.to_digit(10), Some(1));
- ///
- /// assert_eq!('f'.to_digit(16), Some(15));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_digit(self, radix: u32) -> Option<u32>;
-
- /// Returns an iterator that yields the hexadecimal Unicode escape of a
- /// character, as `char`s.
- ///
- /// All characters are escaped with Rust syntax of the form `\\u{NNNN}`
- /// where `NNNN` is the shortest hexadecimal representation of the code
- /// point.
- ///
- /// # Examples
- ///
- /// ```
- /// for i in '❤'.escape_unicode() {
- /// println!("{}", i);
- /// }
- /// ```
- ///
- /// This prints:
- ///
- /// ```text
- /// \
- /// u
- /// {
- /// 2
- /// 7
- /// 6
- /// 4
- /// }
- /// ```
- ///
- /// Collecting into a `String`:
- ///
- /// ```
- /// let heart: String = '❤'.escape_unicode().collect();
- ///
- /// assert_eq!(heart, r"\u{2764}");
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn escape_unicode(self) -> EscapeUnicode;
-
- /// Returns an iterator that yields the 'default' ASCII and
- /// C++11-like literal escape of a character, as `char`s.
- ///
- /// The default is chosen with a bias toward producing literals that are
- /// legal in a variety of languages, including C++11 and similar C-family
- /// languages. The exact rules are:
- ///
- /// * Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
- /// * Single-quote, double-quote and backslash chars are backslash-
- /// escaped.
- /// * Any other chars in the range [0x20,0x7e] are not escaped.
- /// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
- ///
- /// # Examples
- ///
- /// ```
- /// for i in '"'.escape_default() {
- /// println!("{}", i);
- /// }
- /// ```
- ///
- /// This prints:
- ///
- /// ```text
- /// \
- /// "
- /// ```
- ///
- /// Collecting into a `String`:
- ///
- /// ```
- /// let quote: String = '"'.escape_default().collect();
- ///
- /// assert_eq!(quote, "\\\"");
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn escape_default(self) -> EscapeDefault;
-
- /// Returns the number of bytes this character would need if encoded in
- /// UTF-8.
- ///
- /// # Examples
- ///
- /// ```
- /// let n = 'ß'.len_utf8();
- ///
- /// assert_eq!(n, 2);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn len_utf8(self) -> usize;
-
- /// Returns the number of 16-bit code units this character would need if
- /// encoded in UTF-16.
- ///
- /// # Examples
- ///
- /// ```
- /// let n = 'ß'.len_utf16();
- ///
- /// assert_eq!(n, 1);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn len_utf16(self) -> usize;
-
- /// Encodes this character as UTF-8 into the provided byte buffer, and then
- /// returns the number of bytes written.
- ///
- /// If the buffer is not large enough, nothing will be written into it and a
- /// `None` will be returned. A buffer of length four is large enough to
- /// encode any `char`.
- ///
- /// # Examples
- ///
- /// In both of these examples, 'ß' takes two bytes to encode.
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 2];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, Some(2));
- /// ```
- ///
- /// A buffer that's too small:
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 1];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, None);
- /// ```
- #[unstable(feature = "unicode",
- reason = "pending decision about Iterator/Writer/Reader")]
- fn encode_utf8(self, dst: &mut [u8]) -> Option<usize>;
-
- /// Encodes this character as UTF-16 into the provided `u16` buffer, and
- /// then returns the number of `u16`s written.
- ///
- /// If the buffer is not large enough, nothing will be written into it and a
- /// `None` will be returned. A buffer of length 2 is large enough to encode
- /// any `char`.
- ///
- /// # Examples
- ///
- /// In both of these examples, 'ß' takes one `u16` to encode.
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 1];
- ///
- /// let result = 'ß'.encode_utf16(&mut b);
- ///
- /// assert_eq!(result, Some(1));
- /// ```
- ///
- /// A buffer that's too small:
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 0];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, None);
- /// ```
- #[unstable(feature = "unicode",
- reason = "pending decision about Iterator/Writer/Reader")]
- fn encode_utf16(self, dst: &mut [u16]) -> Option<usize>;
-
- /// Returns whether the specified character is considered a Unicode
- /// alphabetic code point.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_alphabetic(self) -> bool;
-
- /// Returns whether the specified character satisfies the 'XID_Start'
- /// Unicode property.
- ///
- /// 'XID_Start' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to ID_Start but modified for closure under NFKx.
- #[unstable(feature = "unicode",
- reason = "mainly needed for compiler internals")]
- fn is_xid_start(self) -> bool;
-
- /// Returns whether the specified `char` satisfies the 'XID_Continue'
- /// Unicode property.
- ///
- /// 'XID_Continue' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
- #[unstable(feature = "unicode",
- reason = "mainly needed for compiler internals")]
- fn is_xid_continue(self) -> bool;
-
- /// Indicates whether a character is in lowercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Lowercase`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_lowercase(self) -> bool;
-
- /// Indicates whether a character is in uppercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Uppercase`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_uppercase(self) -> bool;
-
- /// Indicates whether a character is whitespace.
- ///
- /// Whitespace is defined in terms of the Unicode Property `White_Space`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_whitespace(self) -> bool;
-
- /// Indicates whether a character is alphanumeric.
- ///
- /// Alphanumericness is defined in terms of the Unicode General Categories
- /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_alphanumeric(self) -> bool;
-
- /// Indicates whether a character is a control code point.
- ///
- /// Control code points are defined in terms of the Unicode General
- /// Category `Cc`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_control(self) -> bool;
-
- /// Indicates whether the character is numeric (Nd, Nl, or No).
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_numeric(self) -> bool;
-
- /// Converts a character to its lowercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping. See
- /// `to_uppercase()` for references and more information.
- ///
- /// # Return value
- ///
- /// Returns an iterator which yields the characters corresponding to the
- /// lowercase equivalent of the character. If no conversion is possible then
- /// the input character is returned.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_lowercase(self) -> ToLowercase;
-
- /// Converts a character to its uppercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping: it maps
- /// one Unicode codepoint to its uppercase equivalent according to the
- /// Unicode database [1]. The additional [`SpecialCasing.txt`] is not yet
- /// considered here, but the iterator returned will soon support this form
- /// of case folding.
- ///
- /// A full reference can be found here [2].
- ///
- /// # Return value
- ///
- /// Returns an iterator which yields the characters corresponding to the
- /// uppercase equivalent of the character. If no conversion is possible then
- /// the input character is returned.
- ///
- /// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
- ///
- /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
- ///
- /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_uppercase(self) -> ToUppercase;
-
- /// Returns this character's displayed width in columns, or `None` if it is a
- /// control character other than `'\x00'`.
- ///
- /// `is_cjk` determines behavior for characters in the Ambiguous category:
- /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
- /// In CJK contexts, `is_cjk` should be `true`, else it should be `false`.
- /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
- /// recommends that these characters be treated as 1 column (i.e.,
- /// `is_cjk` = `false`) if the context cannot be reliably determined.
- #[unstable(feature = "unicode",
- reason = "needs expert opinion. is_cjk flag stands out as ugly")]
- fn width(self, is_cjk: bool) -> Option<usize>;
-}
-
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl CharExt for char {
- #[inline]
- fn is_digit(self, radix: u32) -> bool { C::is_digit(self, radix) }
- fn to_digit(self, radix: u32) -> Option<u32> { C::to_digit(self, radix) }
- fn escape_unicode(self) -> EscapeUnicode { C::escape_unicode(self) }
- fn escape_default(self) -> EscapeDefault { C::escape_default(self) }
- fn len_utf8(self) -> usize { C::len_utf8(self) }
- fn len_utf16(self) -> usize { C::len_utf16(self) }
- fn encode_utf8(self, dst: &mut [u8]) -> Option<usize> { C::encode_utf8(self, dst) }
- fn encode_utf16(self, dst: &mut [u16]) -> Option<usize> { C::encode_utf16(self, dst) }
-
- #[inline]
- fn is_alphabetic(self) -> bool {
- match self {
- 'a' ... 'z' | 'A' ... 'Z' => true,
- c if c > '\x7f' => derived_property::Alphabetic(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
-
- #[inline]
- fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
-
- #[inline]
- fn is_lowercase(self) -> bool {
- match self {
- 'a' ... 'z' => true,
- c if c > '\x7f' => derived_property::Lowercase(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_uppercase(self) -> bool {
- match self {
- 'A' ... 'Z' => true,
- c if c > '\x7f' => derived_property::Uppercase(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_whitespace(self) -> bool {
- match self {
- ' ' | '\x09' ... '\x0d' => true,
- c if c > '\x7f' => property::White_Space(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_alphanumeric(self) -> bool {
- self.is_alphabetic() || self.is_numeric()
- }
-
- #[inline]
- fn is_control(self) -> bool { general_category::Cc(self) }
-
- #[inline]
- fn is_numeric(self) -> bool {
- match self {
- '0' ... '9' => true,
- c if c > '\x7f' => general_category::N(c),
- _ => false
- }
- }
-
- #[inline]
- fn to_lowercase(self) -> ToLowercase {
- ToLowercase(Some(conversions::to_lower(self)))
- }
-
- #[inline]
- fn to_uppercase(self) -> ToUppercase {
- ToUppercase(Some(conversions::to_upper(self)))
- }
-
- #[inline]
- fn width(self, is_cjk: bool) -> Option<usize> { charwidth::width(self, is_cjk) }
-}
-
/// An iterator over the lowercase mapping of a given character, returned from
/// the [`to_lowercase` method](../primitive.char.html#method.to_lowercase) on
/// characters.
+S 2015-03-25 a923278
+ bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
+ freebsd-x86_64 cd02c86a9218da73b2a45aff293787010d33bf3e
+ linux-i386 da50141558eed6dabab97b79b2c6a7de4f2d2c5e
+ linux-x86_64 bca03458d28d07506bad4b80e5770b2117286244
+ macos-i386 522d59b23dd885a45e2c5b33e80e76240bb2d9af
+ macos-x86_64 82df09d51d73d119a2f4e4d8041879615cb22081
+ winnt-i386 5056e8def5ab4f4283b8f3aab160cc10231bb28d
+ winnt-x86_64 3f6b35ac12625b4b4b42dfd5eee5f6cbf122794e
+
S 2015-03-17 c64d671
bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
freebsd-x86_64 14ced24e1339a4dd8baa9db69995daa52a948d54
y: isize,
}
-#[cfg(stage0)]
-impl Index<String> for Foo {
- type Output = isize;
-
- fn index<'a>(&'a self, z: &String) -> &'a isize {
- if *z == "x" {
- &self.x
- } else {
- &self.y
- }
- }
-}
-
impl<'a> Index<&'a String> for Foo {
type Output = isize;
projects / rust.git / commitdiff