&"中华Việt Nam"[0..2];
}
+#[test]
+#[should_panic]
+fn test_str_slice_rangetoinclusive_max_panics() {
+ &"hello"[...usize::max_value()];
+}
+
+#[test]
+#[should_panic]
+fn test_str_slice_rangeinclusive_max_panics() {
+ &"hello"[1...usize::max_value()];
+}
+
+#[test]
+#[should_panic]
+fn test_str_slicemut_rangetoinclusive_max_panics() {
+ let mut s = "hello".to_owned();
+ let s: &mut str = &mut s;
+ &mut s[...usize::max_value()];
+}
+
+#[test]
+#[should_panic]
+fn test_str_slicemut_rangeinclusive_max_panics() {
+ let mut s = "hello".to_owned();
+ let s: &mut str = &mut s;
+ &mut s[1...usize::max_value()];
+}
+
+#[test]
+fn test_str_get_maxinclusive() {
+ let mut s = "hello".to_owned();
+ {
+ let s: &str = &s;
+ assert_eq!(s.get(...usize::max_value()), None);
+ assert_eq!(s.get(1...usize::max_value()), None);
+ }
+ {
+ let s: &mut str = &mut s;
+ assert_eq!(s.get(...usize::max_value()), None);
+ assert_eq!(s.get(1...usize::max_value()), None);
+ }
+}
#[test]
fn test_is_char_boundary() {
#[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)
- }
+ index.index(self)
}
}
impl ops::IndexMut<ops::RangeTo<usize>> for str {
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.end) {
- unsafe { self.slice_mut_unchecked(0, index.end) }
- } else {
- super::slice_error_fail(self, 0, index.end)
- }
+ index.index_mut(self)
}
}
#[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())
- }
+ index.index(self)
}
}
impl ops::IndexMut<ops::RangeFrom<usize>> for str {
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.start) {
- let len = self.len();
- unsafe { self.slice_mut_unchecked(index.start, len) }
- } else {
- super::slice_error_fail(self, index.start, self.len())
- }
+ index.index_mut(self)
}
}
#[inline]
fn index(&self, index: ops::RangeInclusive<usize>) -> &str {
- assert!(index.end != usize::max_value(),
- "attempted to index str up to maximum usize");
- self.index(index.start .. index.end+1)
+ index.index(self)
}
}
#[inline]
fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {
- assert!(index.end != usize::max_value(),
- "attempted to index str up to maximum usize");
- self.index(.. index.end+1)
+ index.index(self)
}
}
impl ops::IndexMut<ops::RangeInclusive<usize>> for str {
#[inline]
fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {
- assert!(index.end != usize::max_value(),
- "attempted to index str up to maximum usize");
- self.index_mut(index.start .. index.end+1)
+ index.index_mut(self)
}
}
#[unstable(feature = "inclusive_range",
impl ops::IndexMut<ops::RangeToInclusive<usize>> for str {
#[inline]
fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {
- assert!(index.end != usize::max_value(),
- "attempted to index str up to maximum usize");
- self.index_mut(.. index.end+1)
+ index.index_mut(self)
}
}
}
#[inline]
fn index_mut(self, slice: &mut str) -> &mut Self::Output {
+ // is_char_boundary checks that the index is in [0, .len()]
if slice.is_char_boundary(self.end) {
unsafe { self.get_unchecked_mut(slice) }
} else {
}
#[inline]
fn index_mut(self, slice: &mut str) -> &mut Self::Output {
+ // is_char_boundary checks that the index is in [0, .len()]
if slice.is_char_boundary(self.start) {
unsafe { self.get_unchecked_mut(slice) }
} else {
type Output = str;
#[inline]
fn get(self, slice: &str) -> Option<&Self::Output> {
- (self.start..self.end+1).get(slice)
+ if let Some(end) = self.end.checked_add(1) {
+ (self.start..end).get(slice)
+ } else {
+ None
+ }
}
#[inline]
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
- (self.start..self.end+1).get_mut(slice)
+ if let Some(end) = self.end.checked_add(1) {
+ (self.start..end).get_mut(slice)
+ } else {
+ None
+ }
}
#[inline]
unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {
}
#[inline]
fn index(self, slice: &str) -> &Self::Output {
+ assert!(self.end != usize::max_value(),
+ "attempted to index str up to maximum usize");
(self.start..self.end+1).index(slice)
}
#[inline]
fn index_mut(self, slice: &mut str) -> &mut Self::Output {
+ assert!(self.end != usize::max_value(),
+ "attempted to index str up to maximum usize");
(self.start..self.end+1).index_mut(slice)
}
}
type Output = str;
#[inline]
fn get(self, slice: &str) -> Option<&Self::Output> {
- if slice.is_char_boundary(self.end + 1) {
+ if self.end < usize::max_value() && slice.is_char_boundary(self.end + 1) {
Some(unsafe { self.get_unchecked(slice) })
} else {
None
}
#[inline]
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
- if slice.is_char_boundary(self.end + 1) {
+ if self.end < usize::max_value() && slice.is_char_boundary(self.end + 1) {
Some(unsafe { self.get_unchecked_mut(slice) })
} else {
None
}
#[inline]
fn index(self, slice: &str) -> &Self::Output {
+ assert!(self.end != usize::max_value(),
+ "attempted to index str up to maximum usize");
let end = self.end + 1;
self.get(slice).unwrap_or_else(|| super::slice_error_fail(slice, 0, end))
}
#[inline]
fn index_mut(self, slice: &mut str) -> &mut Self::Output {
+ assert!(self.end != usize::max_value(),
+ "attempted to index str up to maximum usize");
if slice.is_char_boundary(self.end) {
unsafe { self.get_unchecked_mut(slice) }
} else {