Struct regex_syntax::CharClass
+
+ [−]
+
+ [src]
+pub struct CharClass {
+ // some fields omitted
+}A character class.
+ +A character class has a canonical format that the parser guarantees. Its +canonical format is defined by the following invariants:
+ +-
+
- Given any Unicode scalar value, it is matched by at most one character +range in a canonical character class. +
- Every adjacent character range is separated by at least one Unicode +scalar value. +
- Given any pair of character ranges
r1andr2, if +r1.end < r2.start, thenr1comes beforer2in a canonical +character class.
+
In sum, any CharClass produced by this crate's parser is a sorted
+sequence of non-overlapping ranges. This makes it possible to test whether
+a character is matched by a class with a binary search.
Additionally, a character class may be marked case insensitive. If it's +case insensitive, then:
+ +-
+
- Simple case folding has been applied to all ranges. +
- Simple case folding must be applied to a character before testing +whether it matches the character class. +
Methods
impl CharClass
fn matches(&self, c: char) -> bool
+Returns true if c is matched by this character class.
If this character class is case insensitive, then simple case folding
+is applied to c before checking for a match.
fn is_case_insensitive(&self) -> bool
+Returns true if this character class should be matched case +insensitively.
+ +When true, simple case folding has already been applied to the
+class.
Methods from Deref<Target=Vec<ClassRange>>
fn capacity(&self) -> usize
+Returns the number of elements the vector can hold without +reallocating.
+ +Examples
+let vec: Vec<i32> = Vec::with_capacity(10); +assert_eq!(vec.capacity(), 10); ++
fn reserve(&mut self, additional: usize)
+Reserves capacity for at least additional more elements to be inserted
+in the given Vec<T>. The collection may reserve more space to avoid
+frequent reallocations.
Panics
+Panics if the new capacity overflows usize.
Examples
+let mut vec = vec![1]; +vec.reserve(10); +assert!(vec.capacity() >= 11); ++
fn reserve_exact(&mut self, additional: usize)
+Reserves the minimum capacity for exactly additional more elements to
+be inserted in the given Vec<T>. Does nothing if the capacity is already
+sufficient.
Note that the allocator may give the collection more space than it
+requests. Therefore capacity can not be relied upon to be precisely
+minimal. Prefer reserve if future insertions are expected.
Panics
+Panics if the new capacity overflows usize.
Examples
+let mut vec = vec![1]; +vec.reserve_exact(10); +assert!(vec.capacity() >= 11); ++
fn shrink_to_fit(&mut self)
+Shrinks the capacity of the vector as much as possible.
+ +It will drop down as close as possible to the length but the allocator +may still inform the vector that there is space for a few more elements.
+ +Examples
+let mut vec = Vec::with_capacity(10); +vec.extend([1, 2, 3].iter().cloned()); +assert_eq!(vec.capacity(), 10); +vec.shrink_to_fit(); +assert!(vec.capacity() >= 3); ++
fn into_boxed_slice(self) -> Box<[T]>
+Converts the vector into Box<[T]>.
+ +Note that this will drop any excess capacity. Calling this and
+converting back to a vector with into_vec() is equivalent to calling
+shrink_to_fit().
fn truncate(&mut self, len: usize)
+Shorten a vector, dropping excess elements.
+ +If len is greater than the vector's current length, this has no
+effect.
Examples
+let mut vec = vec![1, 2, 3, 4]; +vec.truncate(2); +assert_eq!(vec, [1, 2]); ++
fn as_slice(&self) -> &[T]
+: waiting on RFC revision
+Extracts a slice containing the entire vector.
+ +Equivalent to &s[..].
fn as_mut_slice(&mut self) -> &mut [T]
+: waiting on RFC revision
+Extracts a mutable slice of the entire vector.
+ +Equivalent to &mut s[..].
unsafe fn set_len(&mut self, len: usize)
+Sets the length of a vector.
+ +This will explicitly set the size of the vector, without actually +modifying its buffers, so it is up to the caller to ensure that the +vector is actually the specified size.
+ +Examples
+let mut v = vec![1, 2, 3, 4]; +unsafe { + v.set_len(1); +} ++
fn swap_remove(&mut self, index: usize) -> T
+Removes an element from anywhere in the vector and return it, replacing +it with the last element.
+ +This does not preserve ordering, but is O(1).
+ +Panics
+Panics if index is out of bounds.
Examples
+let mut v = vec!["foo", "bar", "baz", "qux"]; + +assert_eq!(v.swap_remove(1), "bar"); +assert_eq!(v, ["foo", "qux", "baz"]); + +assert_eq!(v.swap_remove(0), "foo"); +assert_eq!(v, ["baz", "qux"]); ++
fn insert(&mut self, index: usize, element: T)
+Inserts an element at position index within the vector, shifting all
+elements after position i one position to the right.
Panics
+Panics if index is greater than the vector's length.
Examples
+let mut vec = vec![1, 2, 3]; +vec.insert(1, 4); +assert_eq!(vec, [1, 4, 2, 3]); +vec.insert(4, 5); +assert_eq!(vec, [1, 4, 2, 3, 5]); ++
fn remove(&mut self, index: usize) -> T
+Removes and returns the element at position index within the vector,
+shifting all elements after position index one position to the left.
Panics
+Panics if index is out of bounds.
Examples
+let mut v = vec![1, 2, 3]; +assert_eq!(v.remove(1), 2); +assert_eq!(v, [1, 3]); ++
fn retain<F>(&mut self, f: F) where F: FnMut(&T) -> bool
+Retains only the elements specified by the predicate.
+ +In other words, remove all elements e such that f(&e) returns false.
+This method operates in place and preserves the order of the retained
+elements.
Examples
+let mut vec = vec![1, 2, 3, 4]; +vec.retain(|&x| x%2 == 0); +assert_eq!(vec, [2, 4]); ++
fn push(&mut self, value: T)
+Appends an element to the back of a collection.
+ +Panics
+Panics if the number of elements in the vector overflows a usize.
Examples
+let mut vec = vec!(1, 2); +vec.push(3); +assert_eq!(vec, [1, 2, 3]); ++
fn pop(&mut self) -> Option<T>
+Removes the last element from a vector and returns it, or None if it is empty.
Examples
+let mut vec = vec![1, 2, 3]; +assert_eq!(vec.pop(), Some(3)); +assert_eq!(vec, [1, 2]); ++
fn append(&mut self, other: &mut Vec<T>)
+: new API, waiting for dust to settle
+Moves all the elements of other into Self, leaving other empty.
Panics
+Panics if the number of elements in the vector overflows a usize.
Examples
+let mut vec = vec![1, 2, 3]; +let mut vec2 = vec![4, 5, 6]; +vec.append(&mut vec2); +assert_eq!(vec, [1, 2, 3, 4, 5, 6]); +assert_eq!(vec2, []); ++
fn drain<R>(&mut self, range: R) -> Drain<T> where R: RangeArgument<usize>
+: recently added, matches RFC
+Create a draining iterator that removes the specified range in the vector +and yields the removed items from start to end. The element range is +removed even if the iterator is not consumed until the end.
+ +Note: It is unspecified how many elements are removed from the vector,
+if the Drain value is leaked.
Panics
+Panics if the starting point is greater than the end point or if +the end point is greater than the length of the vector.
+ +Examples
+ +// Draining using `..` clears the whole vector. +let mut v = vec![1, 2, 3]; +let u: Vec<_> = v.drain(..).collect(); +assert_eq!(v, &[]); +assert_eq!(u, &[1, 2, 3]); ++
fn clear(&mut self)
+Clears the vector, removing all values.
+ +Examples
+let mut v = vec![1, 2, 3]; + +v.clear(); + +assert!(v.is_empty()); ++
fn len(&self) -> usize
+Returns the number of elements in the vector.
+ +Examples
+let a = vec![1, 2, 3]; +assert_eq!(a.len(), 3); ++
fn is_empty(&self) -> bool
+Returns true if the vector contains no elements.
Examples
+let mut v = Vec::new(); +assert!(v.is_empty()); + +v.push(1); +assert!(!v.is_empty()); ++
fn map_in_place<U, F>(self, f: F) -> Vec<U> where F: FnMut(T) -> U
+: API may change to provide stronger guarantees
+Converts a Vec<T> to a Vec<U> where T and U have the same
+size and in case they are not zero-sized the same minimal alignment.
Panics
+Panics if T and U have differing sizes or are not zero-sized and
+have differing minimal alignments.
Examples
+let v = vec![0, 1, 2]; +let w = v.map_in_place(|i| i + 3); +assert_eq!(&w[..], &[3, 4, 5]); + +#[derive(PartialEq, Debug)] +struct Newtype(u8); +let bytes = vec![0x11, 0x22]; +let newtyped_bytes = bytes.map_in_place(|x| Newtype(x)); +assert_eq!(&newtyped_bytes[..], &[Newtype(0x11), Newtype(0x22)]); ++
fn split_off(&mut self, at: usize) -> Vec<T>
+: new API, waiting for dust to settle
+Splits the collection into two at the given index.
+ +Returns a newly allocated Self. self contains elements [0, at),
+and the returned Self contains elements [at, len).
Note that the capacity of self does not change.
Panics
+Panics if at > len.
Examples
+let mut vec = vec![1,2,3]; +let vec2 = vec.split_off(1); +assert_eq!(vec, [1]); +assert_eq!(vec2, [2, 3]); ++
fn resize(&mut self, new_len: usize, value: T)
+: matches collection reform specification; waiting for dust to settle
+Resizes the Vec in-place so that len() is equal to new_len.
Calls either extend() or truncate() depending on whether new_len
+is larger than the current value of len() or not.
Examples
+let mut vec = vec!["hello"]; +vec.resize(3, "world"); +assert_eq!(vec, ["hello", "world", "world"]); + +let mut vec = vec![1, 2, 3, 4]; +vec.resize(2, 0); +assert_eq!(vec, [1, 2]); ++
fn push_all(&mut self, other: &[T])
+: likely to be replaced by a more optimized extend
+Appends all elements in a slice to the Vec.
Iterates over the slice other, clones each element, and then appends
+it to this Vec. The other vector is traversed in-order.
Examples
+let mut vec = vec![1]; +vec.push_all(&[2, 3, 4]); +assert_eq!(vec, [1, 2, 3, 4]); ++
fn dedup(&mut self)
+Removes consecutive repeated elements in the vector.
+ +If the vector is sorted, this removes all duplicates.
+ +Examples
+let mut vec = vec![1, 2, 2, 3, 2]; + +vec.dedup(); + +assert_eq!(vec, [1, 2, 3, 2]); ++