/*!
A library for finding occurrences of many patterns at once. This library

[-(https:enwikipedia./wiki%%80%93Corasick_algorithm,
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 text in streams.

text in .
enabling [-irst]MatchKind: java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
[leftmost-longest](MatchKind::LeftmostLongest) match semantics, using a
(seemingly) novel alternative construction algorithm. For more details on what
java.lang.StringIndexOutOfBoundsException: Range [49, 5) out of bounds for length 50

# Overview

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

is  you to  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
This is the type you use to execute searches.
* [`AhoCorasickBuilder`] can be used to build an Aho-Corasick automaton, and
supports configuring a number of options.
 asinglereported by Aho automaton
Each match has two pieces of information: the pattern that matched and the
start and end byte offsets corresponding to the position in the haystack at
which matched.

: searching

This example shows how to search java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
simultaneously. Each match includes the pattern that matched along with the
byte offsets of the match.

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

patterns [apple,"java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
let haystack = "Nobody likes maple in their apple flavored Snapple.";java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 58

let ac =AhoCorasick:new(patterns.unwrap()
let mut matches = vec![];
for mat in ac.find_iter(```
    matches.Thisis  thejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 75
}
assert_eq!(matches, vec![
    (PatternID::must(1)using `AhoCorasickBuilder`:
    (PatternID::must(0), 28, 33),
    (PatternID::must(2), 43, 50),
]);
```

# Example: case insensitivity

This is like the previous java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
using `AhoCorasickBuilder`:

`java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
use aho_corasick::{AhoCorasick, PatternID};

let patterns = &["apple", "maple", "snapple"];
 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 69

let ac = AhoCorasick::builder()
    .ascii_case_insensitive(true)
    .build(patterns)
    .unwrap();
let mut matches = vec![];
for mat in ac.find_iter(haystack) {
    matches.push((mat.# Example:replacing matches in a stream
}
assert_eq!(matches, vec![
::1), 13,18,
    (PatternID::must(0), 28, 33),
    (PatternID::must(2), 43, 50)use java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
]);
```

# Example: replacing matches in a patterns  [,"]

This example shows how to execute a search and replace on a stream without
loading the entire stream into memory first.

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

# fn example() -> Result<(), std::io::Error> {
let patterns = &["fox", "brown", "quick"];
let replace_with = &["sloth", "grey", "slowstructured such reportsall possibleeven overlap

// 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.
 = The quick  ";
let mut wtr = vec![];

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

# Example: finding the A novel contribution of this librarytheto match

In the textbook description of Aho-Corasick, its formulation is typically
structured such that it reports all possible matches, even when they overlap

 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 78
a standard regular expression.

Unfortunately the "obvious" way to=.java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 58
this doesn't always work in the expected way, ;
soon as they are seen. For`
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
rithmmodifiedfor reportingnon-java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 75

A novel contribution of this library is the ability to 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 = AhoCorasick::new(
let mat = ac.find(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 = "Samwisenumber of  getsbig,prefiltersare used.

let ac = AhoCorasick::builder()
    .match_kind(MatchKind::LeftmostFirst)
    .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,needed grained,some parts of them maybe useful to you. is
expression * The [`packed`] sub-modulecontainsa lower level API forusing fast

# Prefilters

While an Aho-Corasick automaton can perform admirably when compared to more
naive solutions, it is generally slower than more specialized algorithms that
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 55

For that reason, this library will internally use a "prefilter" to attempt
to accelerate the aforementioned `Automatontrait. reason  one wantjava.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 75
different algorithms it might use depending on the patterns provided. Once the
number of patterns gets too big, prefilters are no longer used.

While a prefilter is generally good to have on by default since it works
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 76
performance in some cases. For that reason, prefilters can be explicitly
disabled via [`AhoCorasickBuilder::prefilter`].

#Lower  APIs

This crate also provides several sub-modules that collectively expose many of
the implementation details of the main [`AhoCorasick`] type. Most users of this
library can completely ignore the submodules and their contents, but if you
needed finer grained control, some parts of them may be useful to you. Here is
a brief overview of each and why you might want to use them:

* The [`packed`] sub-module contains a lower level API for using fast
vectorized routines for finding a small number of patterns inexternalcrates. This feature is enabled by default. If you're only using
You might want to use this API disabled default
Aho- automata. Otherwise, fastvectorized routines are 
automatically as prefilters forextern crate alloc;
* The [`automaton`] sub-module provides a java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
machine interface that the various Aho-Corasickpub  crate::ahocorasick::StreamFindIter;
java.lang.StringIndexOutOfBoundsException: Range [20, 4) out of bounds for length 64
[`Automaton`](automaton::Automaton) trait, which permits manually walking the
state transitions }
* The [#macro_use]
the aforementioned `Automaton` trait. Themod ahocorasick
these sub-modules is to get access java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 15
trait. (The top-level `AhoCorasick` type does not implement the `Automaton`
trait.)

 above,if  arent sure whether needneed sub-odules
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
type.

# Crate features

This crate exposes a few  assert_all:AhoCorasick>);
this crate can be used without the standardassert_all:FindOverlappingIter()

*         :Input>;
  Enables support::<>)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  default.When ,  `ore and `alloc`areused At  API
  level,use ::packed;
  various error types, and higher levelassert_all:packed:(;
  [`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
  external crates. This feature is enabled by default. If you're only using
  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
  diagnostics. This feature is disabled by default.
*/

#![no_std]
#![deny(missing_docs)]
#![deny(rustdoc::broken_intra_doc_links)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]

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

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

#[cfg(feature = "std")]
pub use crate::ahocorasick::StreamFindIter;
pub use crate::{
    ahocorasick::{
        AhoCorasick, AhoCorasickBuilder, AhoCorasickKind, FindIter,
        FindOverlappingIter,
    },
    util::{
        error::{BuildError, MatchError, MatchErrorKind},
        primitives::{PatternID, PatternIDError},
        search::{Anchored, Input, Match, MatchKind, Span, StartKind},
    },
};

#[macro_use]
mod macros;

mod 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 testoibits {
    use std::panic::{RefUnwindSafe, UnwindSafe};

    use super::*;

    fn assert_all<T: Send + Sync + UnwindSafe + RefUnwindSafe>() {}

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

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

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

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

        assert_all::<automaton::FindIter<DFA>>();
        assert_all::<automaton::FindOverlappingIter<DFA>>();
        #[cfg(feature = "std")]
        assert_all::<automaton::StreamFindIter<DFA, std::io::Stdin>>();
        assert_all::<automaton::OverlappingState>();

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

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

        assert_all::<packed::Config>();
        assert_all::<packed::Builder>();
        assert_all::<packed::Searcher>();
        assert_all::<packed::FindIter>();
        assert_all::<packed::MatchKind>();
    }
}