# Struct utf8_ranges::Utf8Sequences [−] [src]

    pub struct Utf8Sequences {
        // some fields omitted
    }

An iterator over ranges of matching UTF-8 byte sequences.

The iteration represents an alternation of comprehensive byte sequences that match precisely the set of UTF-8 encoded scalar values.

A byte sequence corresponds to one of the scalar values in the range given if and only if it completely matches exactly one of the sequences of byte ranges produced by this iterator.

Each sequence of byte ranges matches a unique set of bytes. That is, no two sequences will match the same bytes.

# Example

This shows how to match an arbitrary byte sequence against a range of scalar values.

    use utf8_ranges::{Utf8Sequences, Utf8Sequence};

    fn matches(seqs: &[Utf8Sequence], bytes: &[u8]) -> bool {
        for range in seqs {
            if range.matches(bytes) {
                return true;
            }
        }
        false
    }

    // Test the basic multilingual plane.
    let seqs: Vec<_> = Utf8Sequences::new('\u{0}', '\u{FFFF}').collect();

    // UTF-8 encoding of 'a'.
    assert!(matches(&seqs, &[0x61]));
    // UTF-8 encoding of '☃' (`\u{2603}`).
    assert!(matches(&seqs, &[0xE2, 0x98, 0x83]));
    // UTF-8 encoding of `\u{10348}` (outside the BMP).
    assert!(!matches(&seqs, &[0xF0, 0x90, 0x8D, 0x88]));
    // Tries to match against a UTF-8 encoding of a surrogate codepoint,
    // which is invalid UTF-8, and therefore fails, despite the fact that
    // the corresponding codepoint (0xD800) falls in the range given.
    assert!(!matches(&seqs, &[0xED, 0xA0, 0x80]));
    // And fails against plain old invalid UTF-8.
    assert!(!matches(&seqs, &[0xFF, 0xFF]));

If this example seems circuitous, that's because it is! It's meant to be illustrative. In practice, you could just try to decode your byte sequence and compare it with the scalar value range directly. However, this is not always possible (for example, in a byte based automaton).

## Methods

### `impl Utf8Sequences`

#### `fn new(start: char, end: char) -> Self`

Create a new iterator over UTF-8 byte ranges for the scalar value range given.

## Trait Implementations

### `impl Iterator for Utf8Sequences`

#### `type Item = Utf8Sequence`

#### `fn next(&mut self) -> Option<Self::Item>`

#### 1.0.0 `fn size_hint(&self) -> (usize, Option<usize>)`

#### 1.0.0 `fn count(self) -> usize`

#### 1.0.0 `fn last(self) -> Option<Self::Item>`

#### 1.0.0 `fn nth(&mut self, n: usize) -> Option<Self::Item>`

#### 1.0.0 `fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>`

#### 1.0.0 `fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator`

#### 1.0.0 `fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B`

#### 1.0.0 `fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool`

#### 1.0.0 `fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>`

#### 1.0.0 `fn enumerate(self) -> Enumerate<Self>`

#### 1.0.0 `fn peekable(self) -> Peekable<Self>`

#### 1.0.0 `fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool`

#### 1.0.0 `fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool`

#### 1.0.0 `fn skip(self, n: usize) -> Skip<Self>`

#### 1.0.0 `fn take(self, n: usize) -> Take<Self>`

#### 1.0.0 `fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>`

#### 1.0.0 `fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator`

#### 1.0.0 `fn fuse(self) -> Fuse<Self>`

#### 1.0.0 `fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()`

#### 1.0.0 `fn by_ref(&mut self) -> &mut Self`

#### 1.0.0 `fn collect<B>(self) -> B where B: FromIterator<Self::Item>`

#### 1.0.0 `fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool`

#### 1.0.0 `fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B`

#### 1.0.0 `fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool`

#### 1.0.0 `fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool`

#### 1.0.0 `fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool`

#### 1.0.0 `fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool`

#### 1.0.0 `fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator`

#### 1.0.0 `fn max(self) -> Option<Self::Item> where Self::Item: Ord`

#### 1.0.0 `fn min(self) -> Option<Self::Item> where Self::Item: Ord`

#### `fn max_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord`

#### 1.6.0 `fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B`

#### `fn min_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord`

#### 1.6.0 `fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B`

#### 1.0.0 `fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator`

#### 1.0.0 `fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where Self: Iterator<Item=(A, B)>, FromB: Default + Extend<B>, FromA: Default + Extend<A>`

#### 1.0.0 `fn cloned<'a, T>(self) -> Cloned<Self> where T: 'a + Clone, Self: Iterator<Item=&'a T>`

#### 1.0.0 `fn cycle(self) -> Cycle<Self> where Self: Clone`

#### `fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero`

#### `fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One`

#### 1.5.0 `fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord`

#### 1.5.0 `fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>`

#### 1.5.0 `fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>`

#### 1.5.0 `fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>`

#### 1.5.0 `fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`

#### 1.5.0 `fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`

#### 1.5.0 `fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`

#### 1.5.0 `fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)