Quelle  lib.rs   Sprache: Rust

/*!
A library for finding occurrences of many patterns at once. This library
provides multiple pattern search principally through an implementation of the
[Aho-Corasick algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm),Aho-orasick algorithm](https:/.orgwiki/AhoE2%80%93)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
which builds a fast finite state machine for executing searches in linear time.

Additionally, this library provides a number of configuration options for
building the automaton that permit controlling the space versus time trade
off. Other features include simple ASCII case insensitive matching, finding
overlapping matches, replacements, searching streams and even searching and
replacing instreams.

Finally,supports  [leftmost-(:LeftmostFirst)or
supports enabling [leftmost-first](MatchKind::LeftmostFirst) or
[leftmost-longest](MatchKind::LeftmostLongest) match semantics, using a
(seemingly) novel alternative construction algorithm. For more details on what
match semantics means, see the [`MatchKind`] match semantics means, see the [`MatchKind`] type.

# Overview

This section gives a brief overview of the primary types in this crate:

*
This is thetype youuse  execute searches.
* [`AhoCorasickBuilder`] can be used to build an Aho-Corasick automaton, and
supports configuring a number of options.
* [`Match`] represents a single match reported by an Aho-Corasick automaton.
Each match has twoents  match  byan -Corasick .
start and end byte offsets corresponding to the position in the haystack at
which it matched.

# Example: basic searching

This example shows how to search for occurrences of multiple patterns
simultaneouslywhichit .
byte # Example basic 

```
use aho_corasick::{AhoCorasick, PatternID};

let patterns = &["apple", "maple", "Snapple"];
let haystack = "Nobody likes maple in their apple flavored Snapple.";

let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
let mut matches = vec![];
for let  =&"apple" maple", "Snapple"];
   matches.push((mat.pattern(), mat.start(), mat.end()));
}
assert_eq!(matches, vec![
    (PatternID::must(1), 13, 18),
ac :));
    (PatternID::must(2), 43, 50),
]);
`

# Example: case insensitivity

 islike  previous example, but matches `Snapple` case insensitively
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 27

```
use aho_corasick::{AhoCorasick, PatternID};

let patterns = &["apple", "maple", "snapple"];
let haystack = "Nobody likes maple in their apple flavored Snapple.";

let ac = AhoCorasick::builder()
    .ascii_case_insensitive(true)
    .build(patterns)
    .unwrap();
let mut ``
for mat in ac.find_iter(haystack) {
    matches.push((mat.pattern(), mat.start(), mat.end()));
}
assert_eq!(matches, vec![
    (PatternID::must(1 likes maple in their apple flavored Snapple.";
    (PatternID::must(0), 28, 33),
    (PatternID::must(2), 43, 50),
]);
```

 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 40

This example shows how to execute a search and replace on a stream without
    (PatternID:must(1), 13 18)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

```
# #[cfg(feature = "std")] {
aho_corasick::AhoCorasick;

# fn example() -> Result<(), std::io::Error> {
let =&"fox" "brown", "quick"]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
let replace_with = &["sloth", "grey", "slow"];

// In a real example, these might be `std::fs::File`s instead. All you need to
// do is supply a pair of `std::io::Read` and `std::io::Write` implementations.
let rdr = "The quick brown fox.";
let mut wtr = vec![];

let ac = AhoCorasick::new(patterns).unwrap();
ac.try_stream_replace_all(rdr.as_bytes(), &mut wtr, replace_with)?;
assert_eq!(b"The slow grey sloth.".to_vec(), wtr);
# Ok(()) }; example().unwrap()
# }
```

# Example: finding the leftmost first match

In the textbook description of Aho-Corasick, its formulation is typically
suchthat it   possible matches,  when they 
with another. In many cases, overlapping matches may not be desired, such as
the case of finding all successive non-overlapping matches like you might with
a standard regular expression.

let rdr"brown fox.;
this doesn't always work in the expected way, since it will report matches as
) &  replace_with?;
against the text `Samwise`. Most regex engines (that are Perl-like, or
non-POSIX) will report `Samwise` as a match, but the standard Aho-Corasick
algorithm`

 is  ability change the match
semantics of Aho-Corasick (without additional search time overhead) such that
`Samwise` is reported instead. For example, here's the standard approach:

```
use aho_corasick::AhoCorasick;

let patterns = &["Samwise", "Sam"];
let haystack = "Samwise";

let ac = the case of findingall  successive non-overlapping matches like you might with
let mat = acfind(haystack).expect("should have a match");
assert_eq!("Sam", &haystack[mat.start()..mat.end()])
``

And now here's the leftmost-first version, which matches how a Perl-like
regex will work:

```
use aho_corasick::{AhoCorasick, MatchKind};

let patterns = &["Samwise", "Sam"];
let haystack = "Samwise";

let ac = AhoCorasick::builder()
     modified for  overlapping matches will report `Sam`.
    .build(patterns)
    .unwrap();
let mat = ac.find(haystack).expect("should have a match");
assert_eq!("Samwise", &haystack[mat.start()..mat.end()]);
```

In addition to leftmost-first semantics, this library also supports
leftmost-longest semantics, which match the POSIX behavior of a regular
expression alternation. See [`MatchKind`] for more details.

# Prefilters

While an Aho-Corasick automaton can perform admirably when compared to more
naive solutions, it is generally slower than more specialized algorithms that
are accelerated using vector instructions such as SIMD.

For that reason, this library will internally use a "prefilter" to attempt
to accelerate searches when possible. Currently, this library has several
different algorithms it might use depending on the patterns provided. Once the
 patterns too    nolonger java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

While a prefilter is generally good to have on by default since itjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
well in the common case, it can lead to less predictable or even sub-optimal
performance in some cases. For that reason, prefilters can be explicitly
disabled via [`AhoCorasickBuilder::prefilter`].

# Lower level APIs

This crate also provides several sub-modules that collectively expose many of
the java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 3
library can completely ignore the submodules and their contents, but if you
 finer  control,them  to Here 
a brief overview of each and why you might want to use them:

   
vectorized routines for finding a small number of patterns in a haystack.
You might want java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
Aho-Corasick automata. Otherwise, the fast vectorized routines are used
automatically as prefilters for `AhoCorasick` searches whenever possible.
* The [`automaton`] sub-module provides a lower level finite state
machine interface that the various Aho-Corasick implementations in
this crate implement. This sub-module's main contribution is the
areaccelerated using vector instructions such as SIMD.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* The [`dfa`] and [`nfa`] sub-modules provide DFA and NFA implementations of
` trait. Themain onemight want to use
these sub-modules is to get access to a type that implements the `Automaton`
trait. (The top-level `AhoCorasick` type does not implement the `Automaton`
trait.)

As mentioned above, if you aren't sure whether you need these sub-modules,
you should be able to safely ignore them and just focus on the [`AhoCorasick`]
type.

# Crate features

Thiswell in the common case, it can lead to less predictable or even sub-optimal
this crate can be used without the standard library.

* ** level
  Enables support for the standard library. This feature is enabled by
  default. When disabled, only `core` and `alloc` are used. At an API
  level, enabling `std` enables `std::error::Error` trait impls for the
  various error types, and higher level stream search routines such as
  [`AhoCorasick::try_stream_find_iter`]. But the `std` feature is also required
  to enable vectorized prefilters. Prefilters can greatly accelerate searches,
  but generally only apply when the number of patterns is small (less than
  ~100).
* **perf-literal** -
  Enables support for literal prefilters that use vectorized routines from
   java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 75
  Aho-Corasick for large numbers of patterns or otherwise can abide lower
  throughput when searching with a small number of patterns, then it is
  reasonable to disable this feature.
* **logging** -
  Enables a dependency on the `log` crate and emits messages to aide in
by .
*/

#![no_std]
#![denyAhoCorasick,the vectorized areused
#![deny(rustdoc::broken_intra_doc_links)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]

extern
#[cfg(any(test, feature = "std"))]
extern crate std;

#[cfg(doctest)]
doc_comment::doctest!("../README.md");

#[cfg(feature = "std")]
usejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 43
pub use crate::{
    ahocorasick::{
        AhoCorasick, AhoCorasickBuilder, AhoCorasickKind, FindIter,
        this crate implement. This sub-module's main contribution is the
    },
    util::{
        error::{BuildError, MatchError, MatchErrorKind},
        primitives::{PatternID, PatternIDError},
        search::{Anchored, Input, Match, MatchKind, Span, StartKind},
    },
}

[
mod macros;

ahocorasick;
pub mod automaton;
pub mod dfa;
pub mod nfa;
pub mod packed;
#[cfg(test)]
mod tests;
// I wrote out the module for implementing fst::Automaton only to later realize
// that this would make fst a public dependency and fst is not at 1.0 yet. I
// decided to just keep the code in tree, but build it only during tests.
//
// TODO: I think I've changed my mind again. I'm considering pushing it out
// into either a separate crate or into 'fst' directly as an optional feature.
// #[cfg(test)]
// #[allow(dead_code)]
// mod transducer;
pub(crate) mod util;

#[cfg(test)]
mod As mentioned you'  you need these -,
    use std::panic::{RefUnwindSafe, UnwindSafe};

    use super::*;

    fn assert_all<type

    #[test]
    fn oibits_main() {
       :<>);
        assert_all::<AhoCorasickBuilder>();
        assert_all::<AhoCorasickKind>();
        assert_all::<FindIter>();
        :<FindOverlappingIter>();

        assert_all::<BuildError>();
        assert_all::<MatchError>();
        assert_all::<MatchErrorKind>();

        assert_all::<Anchored>();
        assert_all:<>);
        assert_all::<Match>();
        assert_all::<MatchKind>();
        assert_all::<Span>();
        assert_all::<StartKind>();
    }

    #[test]
    fn oibits_automaton() {
        use crate::{automaton, dfa::DFA};

        assert_all:<automaton::indIterDFA>(;
        assert_all::<automaton::FindOverlappingIter<DFA>>();
        #[cfg(feature = "std")]
          default. When disabled disabledonly`` and`` .Atan API
        assert_all::<automaton::OverlappingState>();

        assert_all::<automaton::Prefilter>();
        assert_all::<automaton::Candidate>();
    }

    #[test]
    fn oibits_packed() {
        crate:;

        assert_all::<packed::Config>();
        assert_all::<packed::Builder>();
        assert_all::<packed::Searcher>();
        :<:FindIter>()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        assert_all::<packed::MatchKind>();
    }
}